# 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 4.9497474655508995*${_u_distance}
variable latticeconst_converted equal 4.9497474655508995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.9497474655509
Lattice spacing in x,y,z = 4.9497475 4.9497475 4.9497475
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (49.497475 49.497475 49.497475)
  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 (49.497475 49.497475 49.497475)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Pb

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

kim interactions Pb
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Pb__MO_019208265157_001
pair_coeff * * Pb
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 207.2

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 121268.812771005 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_019208265157_001#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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.236 | 4.236 | 4.236 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -7987.791      -7987.791      -8160          -8160           333.15         333.15         121268.81      121268.81      1516.7921      1516.7921    
      1000  -7787.2804     -7787.2804     -7968.686      -7968.686       350.94147      350.94147      124886.58      124886.58      81.448528      81.448528    
Loop time of 269.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.320 ns/day, 74.997 hours/ns, 3.704 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    | 268.92     | 268.92     | 268.92     |   0.0 | 99.60
Neigh   | 0.16251    | 0.16251    | 0.16251    |   0.0 |  0.06
Comm    | 0.13639    | 0.13639    | 0.13639    |   0.0 |  0.05
Output  | 0.00023444 | 0.00023444 | 0.00023444 |   0.0 |  0.00
Modify  | 0.67811    | 0.67811    | 0.67811    |   0.0 |  0.25
Other   |            | 0.09396    |            |       |  0.03

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

Total # of neighbors = 218350
Ave neighs/atom = 54.5875
Neighbor list builds = 4
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -7787.2804     -7787.2804     -7968.686      -7968.686       350.94147      350.94147      124886.58      124886.58      81.448528      81.448528    
      2000  -7803.3843     -7803.3843     -7974.853      -7974.853       331.7178       331.7178       124892.2       124892.2      -282.73676     -282.73676    
Loop time of 270.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.319 ns/day, 75.256 hours/ns, 3.691 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    | 269.85     | 269.85     | 269.85     |   0.0 | 99.60
Neigh   | 0.16063    | 0.16063    | 0.16063    |   0.0 |  0.06
Comm    | 0.13254    | 0.13254    | 0.13254    |   0.0 |  0.05
Output  | 0.0002997  | 0.0002997  | 0.0002997  |   0.0 |  0.00
Modify  | 0.68658    | 0.68658    | 0.68658    |   0.0 |  0.25
Other   |            | 0.09456    |            |       |  0.03

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

Total # of neighbors = 218468
Ave neighs/atom = 54.617
Neighbor list builds = 4
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -7803.3843     -7803.3843     -7974.853      -7974.853       331.7178       331.7178       124892.2       124892.2      -282.73676     -282.73676    
      3000  -7799.9548     -7799.9548     -7971.9465     -7971.9465      332.72944      332.72944      124919.75      124919.75     -143.55108     -143.55108    
Loop time of 264.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.417 hours/ns, 3.784 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    | 263.26     | 263.26     | 263.26     |   0.0 | 99.60
Neigh   | 0.15766    | 0.15766    | 0.15766    |   0.0 |  0.06
Comm    | 0.13247    | 0.13247    | 0.13247    |   0.0 |  0.05
Output  | 0.00027553 | 0.00027553 | 0.00027553 |   0.0 |  0.00
Modify  | 0.66288    | 0.66288    | 0.66288    |   0.0 |  0.25
Other   |            | 0.091      |            |       |  0.03

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

Total # of neighbors = 218294
Ave neighs/atom = 54.5735
Neighbor list builds = 4
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -7799.9548     -7799.9548     -7971.9465     -7971.9465      332.72944      332.72944      124919.75      124919.75     -143.55108     -143.55108    
      4000  -7805.4482     -7805.4482     -7975.4703     -7975.4703      328.91917      328.91917      124808.8       124808.8       48.41283       48.41283     
Loop time of 260.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.230 hours/ns, 3.846 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    | 259.01     | 259.01     | 259.01     |   0.0 | 99.61
Neigh   | 0.15767    | 0.15767    | 0.15767    |   0.0 |  0.06
Comm    | 0.13088    | 0.13088    | 0.13088    |   0.0 |  0.05
Output  | 0.00027446 | 0.00027446 | 0.00027446 |   0.0 |  0.00
Modify  | 0.64072    | 0.64072    | 0.64072    |   0.0 |  0.25
Other   |            | 0.08955    |            |       |  0.03

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

Total # of neighbors = 218290
Ave neighs/atom = 54.5725
Neighbor list builds = 4
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -7805.4482     -7805.4482     -7975.4703     -7975.4703      328.91917      328.91917      124808.8       124808.8       48.41283       48.41283     
      5000  -7798.0796     -7798.0796     -7974.5689     -7974.5689      341.43057      341.43057      124721.95      124721.95      456.85924      456.85924    
Loop time of 259.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.018 hours/ns, 3.857 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    | 258.24     | 258.24     | 258.24     |   0.0 | 99.61
Neigh   | 0.15757    | 0.15757    | 0.15757    |   0.0 |  0.06
Comm    | 0.12944    | 0.12944    | 0.12944    |   0.0 |  0.05
Output  | 0.00023084 | 0.00023084 | 0.00023084 |   0.0 |  0.00
Modify  | 0.64624    | 0.64624    | 0.64624    |   0.0 |  0.25
Other   |            | 0.08935    |            |       |  0.03

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

Total # of neighbors = 218250
Ave neighs/atom = 54.5625
Neighbor list builds = 4
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 = 339.60906300736, Press = -155.494257284713
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -7798.0796     -7798.0796     -7974.5689     -7974.5689      341.43057      341.43057      124721.95      124721.95      456.85924      456.85924    
      6000  -7809.5326     -7809.5326     -7982.018      -7982.018       333.68484      333.68484      124721.12      124721.12     -38.434259     -38.434259    
Loop time of 260.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.392 hours/ns, 3.837 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    | 259.56     | 259.56     | 259.56     |   0.0 | 99.60
Neigh   | 0.15797    | 0.15797    | 0.15797    |   0.0 |  0.06
Comm    | 0.13103    | 0.13103    | 0.13103    |   0.0 |  0.05
Output  | 0.00023343 | 0.00023343 | 0.00023343 |   0.0 |  0.00
Modify  | 0.67067    | 0.67067    | 0.67067    |   0.0 |  0.26
Other   |            | 0.08903    |            |       |  0.03

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

Total # of neighbors = 217962
Ave neighs/atom = 54.4905
Neighbor list builds = 4
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 = 333.784671814463, Press = -14.4649978848964
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -7809.5326     -7809.5326     -7982.018      -7982.018       333.68484      333.68484      124721.12      124721.12     -38.434259     -38.434259    
      7000  -7808.5834     -7808.5834     -7979.2407     -7979.2407      330.148        330.148        124791.21      124791.21     -175.12318     -175.12318    
Loop time of 259.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.151 hours/ns, 3.850 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    | 258.7      | 258.7      | 258.7      |   0.0 | 99.60
Neigh   | 0.15768    | 0.15768    | 0.15768    |   0.0 |  0.06
Comm    | 0.13004    | 0.13004    | 0.13004    |   0.0 |  0.05
Output  | 0.00019277 | 0.00019277 | 0.00019277 |   0.0 |  0.00
Modify  | 0.67015    | 0.67015    | 0.67015    |   0.0 |  0.26
Other   |            | 0.08932    |            |       |  0.03

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

Total # of neighbors = 218384
Ave neighs/atom = 54.596
Neighbor list builds = 4
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 = 333.337596021426, Press = -1.17580752111621
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.227 | 4.227 | 4.227 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -7808.5834     -7808.5834     -7979.2407     -7979.2407      330.148        330.148        124791.21      124791.21     -175.12318     -175.12318    
      8000  -7807.6325     -7807.6325     -7980.9158     -7980.9158      335.22829      335.22829      124538.62      124538.62      670.49466      670.49466    
Loop time of 258.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.334 ns/day, 71.944 hours/ns, 3.861 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    | 257.95     | 257.95     | 257.95     |   0.0 | 99.60
Neigh   | 0.15805    | 0.15805    | 0.15805    |   0.0 |  0.06
Comm    | 0.1311     | 0.1311     | 0.1311     |   0.0 |  0.05
Output  | 0.00022808 | 0.00022808 | 0.00022808 |   0.0 |  0.00
Modify  | 0.6702     | 0.6702     | 0.6702     |   0.0 |  0.26
Other   |            | 0.08904    |            |       |  0.03

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

Total # of neighbors = 218272
Ave neighs/atom = 54.568
Neighbor list builds = 4
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 = 333.274601555183, Press = 0.547548313420132
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -7807.6325     -7807.6325     -7980.9158     -7980.9158      335.22829      335.22829      124538.62      124538.62      670.49466      670.49466    
      9000  -7811.1847     -7811.1847     -7983.3186     -7983.3186      333.00456      333.00456      124649.53      124649.53      161.77861      161.77861    
Loop time of 260.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.280 hours/ns, 3.843 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    | 259.16     | 259.16     | 259.16     |   0.0 | 99.60
Neigh   | 0.15786    | 0.15786    | 0.15786    |   0.0 |  0.06
Comm    | 0.13066    | 0.13066    | 0.13066    |   0.0 |  0.05
Output  | 0.00019535 | 0.00019535 | 0.00019535 |   0.0 |  0.00
Modify  | 0.66973    | 0.66973    | 0.66973    |   0.0 |  0.26
Other   |            | 0.08971    |            |       |  0.03

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

Total # of neighbors = 218260
Ave neighs/atom = 54.565
Neighbor list builds = 4
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 = 333.19548946372, Press = -3.18297613184598
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -7811.1847     -7811.1847     -7983.3186     -7983.3186      333.00456      333.00456      124649.53      124649.53      161.77861      161.77861    
     10000  -7803.7227     -7803.7227     -7979.8202     -7979.8202      340.67253      340.67253      124771         124771        -57.408699     -57.408699    
Loop time of 259.158 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 71.988 hours/ns, 3.859 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    | 258.15     | 258.15     | 258.15     |   0.0 | 99.61
Neigh   | 0.11837    | 0.11837    | 0.11837    |   0.0 |  0.05
Comm    | 0.12946    | 0.12946    | 0.12946    |   0.0 |  0.05
Output  | 0.00019198 | 0.00019198 | 0.00019198 |   0.0 |  0.00
Modify  | 0.66791    | 0.66791    | 0.66791    |   0.0 |  0.26
Other   |            | 0.08873    |            |       |  0.03

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

Total # of neighbors = 218298
Ave neighs/atom = 54.5745
Neighbor list builds = 3
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 = 333.583078451449, Press = -3.69659247326494
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -7803.7227     -7803.7227     -7979.8202     -7979.8202      340.67253      340.67253      124771         124771        -57.408699     -57.408699    
     11000  -7801.0628     -7801.0628     -7981.6057     -7981.6057      349.27256      349.27256      124813.57      124813.57     -379.84775     -379.84775    
Loop time of 259.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.103 hours/ns, 3.853 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    | 258.53     | 258.53     | 258.53     |   0.0 | 99.60
Neigh   | 0.15763    | 0.15763    | 0.15763    |   0.0 |  0.06
Comm    | 0.13025    | 0.13025    | 0.13025    |   0.0 |  0.05
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.66815    | 0.66815    | 0.66815    |   0.0 |  0.26
Other   |            | 0.08904    |            |       |  0.03

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

Total # of neighbors = 218132
Ave neighs/atom = 54.533
Neighbor list builds = 4
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 = 333.66667627679, Press = -8.507156495
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -7801.0628     -7801.0628     -7981.6057     -7981.6057      349.27256      349.27256      124813.57      124813.57     -379.84775     -379.84775    
     12000  -7804.9552     -7804.9552     -7977.3813     -7977.3813      333.56993      333.56993      124900.39      124900.39     -409.49277     -409.49277    
Loop time of 259.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.078 hours/ns, 3.854 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    | 258.44     | 258.44     | 258.44     |   0.0 | 99.60
Neigh   | 0.15739    | 0.15739    | 0.15739    |   0.0 |  0.06
Comm    | 0.12857    | 0.12857    | 0.12857    |   0.0 |  0.05
Output  | 0.00019312 | 0.00019312 | 0.00019312 |   0.0 |  0.00
Modify  | 0.66826    | 0.66826    | 0.66826    |   0.0 |  0.26
Other   |            | 0.08906    |            |       |  0.03

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

Total # of neighbors = 218380
Ave neighs/atom = 54.595
Neighbor list builds = 4
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 = 333.83575962876, Press = -2.49130282151446
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -7804.9552     -7804.9552     -7977.3813     -7977.3813      333.56993      333.56993      124900.39      124900.39     -409.49277     -409.49277    
     13000  -7804.1457     -7804.1457     -7978.1375     -7978.1375      336.5989       336.5989       124801.27      124801.27     -139.08283     -139.08283    
Loop time of 258.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.334 ns/day, 71.927 hours/ns, 3.862 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    | 257.93     | 257.93     | 257.93     |   0.0 | 99.61
Neigh   | 0.11856    | 0.11856    | 0.11856    |   0.0 |  0.05
Comm    | 0.12989    | 0.12989    | 0.12989    |   0.0 |  0.05
Output  | 0.00019285 | 0.00019285 | 0.00019285 |   0.0 |  0.00
Modify  | 0.66841    | 0.66841    | 0.66841    |   0.0 |  0.26
Other   |            | 0.08869    |            |       |  0.03

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

Total # of neighbors = 218296
Ave neighs/atom = 54.574
Neighbor list builds = 3
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 = 333.750719338408, Press = -1.29322121538055
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -7804.1457     -7804.1457     -7978.1375     -7978.1375      336.5989       336.5989       124801.27      124801.27     -139.08283     -139.08283    
     14000  -7801.073      -7801.073      -7976.2839     -7976.2839      338.95726      338.95726      124766.53      124766.53      179.98031      179.98031    
Loop time of 259.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.084 hours/ns, 3.854 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    | 258.46     | 258.46     | 258.46     |   0.0 | 99.60
Neigh   | 0.15781    | 0.15781    | 0.15781    |   0.0 |  0.06
Comm    | 0.12981    | 0.12981    | 0.12981    |   0.0 |  0.05
Output  | 0.0001948  | 0.0001948  | 0.0001948  |   0.0 |  0.00
Modify  | 0.66913    | 0.66913    | 0.66913    |   0.0 |  0.26
Other   |            | 0.08879    |            |       |  0.03

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

Total # of neighbors = 218186
Ave neighs/atom = 54.5465
Neighbor list builds = 4
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 = 333.831502339839, Press = -1.27246655597901
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.227 | 4.227 | 4.227 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -7801.073      -7801.073      -7976.2839     -7976.2839      338.95726      338.95726      124766.53      124766.53      179.98031      179.98031    
     15000  -7810.8403     -7810.8403     -7984.5057     -7984.5057      335.96748      335.96748      124553.27      124553.27      436.83926      436.83926    
Loop time of 278.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.310 ns/day, 77.370 hours/ns, 3.590 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    | 277.44     | 277.44     | 277.44     |   0.0 | 99.61
Neigh   | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.04
Comm    | 0.13479    | 0.13479    | 0.13479    |   0.0 |  0.05
Output  | 0.00024617 | 0.00024617 | 0.00024617 |   0.0 |  0.00
Modify  | 0.74086    | 0.74086    | 0.74086    |   0.0 |  0.27
Other   |            | 0.09461    |            |       |  0.03

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

Total # of neighbors = 218334
Ave neighs/atom = 54.5835
Neighbor list builds = 3
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 = 333.793539555185, Press = -2.6382817026052
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -7810.8403     -7810.8403     -7984.5057     -7984.5057      335.96748      335.96748      124553.27      124553.27      436.83926      436.83926    
     16000  -7810.782      -7810.782      -7982.6914     -7982.6914      332.57037      332.57037      124662.46      124662.46      84.070682      84.070682    
Loop time of 304.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.545 hours/ns, 3.286 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.1      | 303.1      | 303.1      |   0.0 | 99.58
Neigh   | 0.17117    | 0.17117    | 0.17117    |   0.0 |  0.06
Comm    | 0.14701    | 0.14701    | 0.14701    |   0.0 |  0.05
Output  | 0.00024415 | 0.00024415 | 0.00024415 |   0.0 |  0.00
Modify  | 0.84474    | 0.84474    | 0.84474    |   0.0 |  0.28
Other   |            | 0.1026     |            |       |  0.03

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

Total # of neighbors = 218216
Ave neighs/atom = 54.554
Neighbor list builds = 4
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 = 333.686166101918, Press = -3.55890179231641
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -7810.782      -7810.782      -7982.6914     -7982.6914      332.57037      332.57037      124662.46      124662.46      84.070682      84.070682    
     17000  -7810.6275     -7810.6275     -7984.9751     -7984.9751      337.28733      337.28733      124698.96      124698.96     -156.69099     -156.69099    
Loop time of 275.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.517 hours/ns, 3.630 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    | 274.33     | 274.33     | 274.33     |   0.0 | 99.59
Neigh   | 0.16226    | 0.16226    | 0.16226    |   0.0 |  0.06
Comm    | 0.13713    | 0.13713    | 0.13713    |   0.0 |  0.05
Output  | 0.00019164 | 0.00019164 | 0.00019164 |   0.0 |  0.00
Modify  | 0.73549    | 0.73549    | 0.73549    |   0.0 |  0.27
Other   |            | 0.09507    |            |       |  0.03

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

Total # of neighbors = 218116
Ave neighs/atom = 54.529
Neighbor list builds = 4
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 = 333.767311857267, Press = -1.35802021015921
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -7810.6275     -7810.6275     -7984.9751     -7984.9751      337.28733      337.28733      124698.96      124698.96     -156.69099     -156.69099    
     18000  -7810.7138     -7810.7138     -7980.663      -7980.663       328.77818      328.77818      124784.05      124784.05     -268.06311     -268.06311    
Loop time of 274.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.365 hours/ns, 3.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 273.79     | 273.79     | 273.79     |   0.0 | 99.59
Neigh   | 0.16561    | 0.16561    | 0.16561    |   0.0 |  0.06
Comm    | 0.13741    | 0.13741    | 0.13741    |   0.0 |  0.05
Output  | 0.00025605 | 0.00025605 | 0.00025605 |   0.0 |  0.00
Modify  | 0.73029    | 0.73029    | 0.73029    |   0.0 |  0.27
Other   |            | 0.09372    |            |       |  0.03

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

Total # of neighbors = 218398
Ave neighs/atom = 54.5995
Neighbor list builds = 4
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 = 333.709527278633, Press = -0.919210638863793
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -7810.7138     -7810.7138     -7980.663      -7980.663       328.77818      328.77818      124784.05      124784.05     -268.06311     -268.06311    
     19000  -7806.7523     -7806.7523     -7980.4729     -7980.4729      336.07438      336.07438      124712.44      124712.44      46.509919      46.509919    
Loop time of 271.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.319 ns/day, 75.318 hours/ns, 3.688 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    | 270.05     | 270.05     | 270.05     |   0.0 | 99.60
Neigh   | 0.16059    | 0.16059    | 0.16059    |   0.0 |  0.06
Comm    | 0.13313    | 0.13313    | 0.13313    |   0.0 |  0.05
Output  | 0.00019322 | 0.00019322 | 0.00019322 |   0.0 |  0.00
Modify  | 0.71101    | 0.71101    | 0.71101    |   0.0 |  0.26
Other   |            | 0.09272    |            |       |  0.03

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

Total # of neighbors = 218140
Ave neighs/atom = 54.535
Neighbor list builds = 4
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 = 333.589738135539, Press = -1.6411043211901
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -7806.7523     -7806.7523     -7980.4729     -7980.4729      336.07438      336.07438      124712.44      124712.44      46.509919      46.509919    
     20000  -7802.8477     -7802.8477     -7978.5702     -7978.5702      339.947        339.947        124866.89      124866.89     -264.59446     -264.59446    
Loop time of 260.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.318 hours/ns, 3.841 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    | 259.3      | 259.3      | 259.3      |   0.0 | 99.60
Neigh   | 0.15799    | 0.15799    | 0.15799    |   0.0 |  0.06
Comm    | 0.13106    | 0.13106    | 0.13106    |   0.0 |  0.05
Output  | 0.00019443 | 0.00019443 | 0.00019443 |   0.0 |  0.00
Modify  | 0.6696     | 0.6696     | 0.6696     |   0.0 |  0.26
Other   |            | 0.09034    |            |       |  0.03

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

Total # of neighbors = 218040
Ave neighs/atom = 54.51
Neighbor list builds = 4
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 = 333.540318168523, Press = -1.30257289459514
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -7802.8477     -7802.8477     -7978.5702     -7978.5702      339.947        339.947        124866.89      124866.89     -264.59446     -264.59446    
     21000  -7807.1641     -7807.1641     -7980.47       -7980.47        335.2721       335.2721       124619.37      124619.37      387.46818      387.46818    
Loop time of 259.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.137 hours/ns, 3.851 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    | 258.64     | 258.64     | 258.64     |   0.0 | 99.60
Neigh   | 0.15768    | 0.15768    | 0.15768    |   0.0 |  0.06
Comm    | 0.13086    | 0.13086    | 0.13086    |   0.0 |  0.05
Output  | 0.00023979 | 0.00023979 | 0.00023979 |   0.0 |  0.00
Modify  | 0.67025    | 0.67025    | 0.67025    |   0.0 |  0.26
Other   |            | 0.0905     |            |       |  0.03

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

Total # of neighbors = 218038
Ave neighs/atom = 54.5095
Neighbor list builds = 4
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 = 333.593135447146, Press = -1.67467977872593
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -7807.1641     -7807.1641     -7980.47       -7980.47        335.2721       335.2721       124619.37      124619.37      387.46818      387.46818    
     22000  -7808.7558     -7808.7558     -7980.7137     -7980.7137      332.66418      332.66418      124701.21      124701.21      88.235793      88.235793    
Loop time of 259.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.054 hours/ns, 3.855 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    | 258.35     | 258.35     | 258.35     |   0.0 | 99.60
Neigh   | 0.15759    | 0.15759    | 0.15759    |   0.0 |  0.06
Comm    | 0.13055    | 0.13055    | 0.13055    |   0.0 |  0.05
Output  | 0.00019308 | 0.00019308 | 0.00019308 |   0.0 |  0.00
Modify  | 0.6699     | 0.6699     | 0.6699     |   0.0 |  0.26
Other   |            | 0.09034    |            |       |  0.03

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

Total # of neighbors = 218040
Ave neighs/atom = 54.51
Neighbor list builds = 4
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 = 333.60833401759, Press = -1.07288988902949
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -7808.7558     -7808.7558     -7980.7137     -7980.7137      332.66418      332.66418      124701.21      124701.21      88.235793      88.235793    
     23000  -7804.7253     -7804.7253     -7978.8453     -7978.8453      336.84696      336.84696      124886.16      124886.16     -435.30154     -435.30154    
Loop time of 260.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.363 hours/ns, 3.839 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    | 259.46     | 259.46     | 259.46     |   0.0 | 99.60
Neigh   | 0.15839    | 0.15839    | 0.15839    |   0.0 |  0.06
Comm    | 0.13107    | 0.13107    | 0.13107    |   0.0 |  0.05
Output  | 0.00019346 | 0.00019346 | 0.00019346 |   0.0 |  0.00
Modify  | 0.66968    | 0.66968    | 0.66968    |   0.0 |  0.26
Other   |            | 0.09104    |            |       |  0.03

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

Total # of neighbors = 218304
Ave neighs/atom = 54.576
Neighbor list builds = 4
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 = 333.595063113297, Press = -1.14493224513303
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -7804.7253     -7804.7253     -7978.8453     -7978.8453      336.84696      336.84696      124886.16      124886.16     -435.30154     -435.30154    
     24000  -7808.9679     -7808.9679     -7982.0703     -7982.0703      334.8782       334.8782       124856.12      124856.12     -522.08958     -522.08958    
Loop time of 259.796 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.166 hours/ns, 3.849 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    | 258.75     | 258.75     | 258.75     |   0.0 | 99.60
Neigh   | 0.15839    | 0.15839    | 0.15839    |   0.0 |  0.06
Comm    | 0.13001    | 0.13001    | 0.13001    |   0.0 |  0.05
Output  | 0.00019277 | 0.00019277 | 0.00019277 |   0.0 |  0.00
Modify  | 0.67078    | 0.67078    | 0.67078    |   0.0 |  0.26
Other   |            | 0.09084    |            |       |  0.03

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

Total # of neighbors = 218110
Ave neighs/atom = 54.5275
Neighbor list builds = 4
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 = 333.638579909917, Press = -1.73161718397675
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -7808.9679     -7808.9679     -7982.0703     -7982.0703      334.8782       334.8782       124856.12      124856.12     -522.08958     -522.08958    
     25000  -7807.3913     -7807.3913     -7982.4555     -7982.4555      338.67344      338.67344      124720.01      124720.01      11.778615      11.778615    
Loop time of 260.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.273 hours/ns, 3.843 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    | 259.17     | 259.17     | 259.17     |   0.0 | 99.61
Neigh   | 0.11831    | 0.11831    | 0.11831    |   0.0 |  0.05
Comm    | 0.12842    | 0.12842    | 0.12842    |   0.0 |  0.05
Output  | 0.00019345 | 0.00019345 | 0.00019345 |   0.0 |  0.00
Modify  | 0.67388    | 0.67388    | 0.67388    |   0.0 |  0.26
Other   |            | 0.09163    |            |       |  0.04

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

Total # of neighbors = 218164
Ave neighs/atom = 54.541
Neighbor list builds = 3
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 = 333.570403269183, Press = -1.19944522571209
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -7807.3913     -7807.3913     -7982.4555     -7982.4555      338.67344      338.67344      124720.01      124720.01      11.778615      11.778615    
     26000  -7807.0242     -7807.0242     -7978.5586     -7978.5586      331.84511      331.84511      124821.31      124821.31     -157.00313     -157.00313    
Loop time of 284.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 78.938 hours/ns, 3.519 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    | 283.01     | 283.01     | 283.01     |   0.0 | 99.59
Neigh   | 0.17029    | 0.17029    | 0.17029    |   0.0 |  0.06
Comm    | 0.13867    | 0.13867    | 0.13867    |   0.0 |  0.05
Output  | 0.00024592 | 0.00024592 | 0.00024592 |   0.0 |  0.00
Modify  | 0.75938    | 0.75938    | 0.75938    |   0.0 |  0.27
Other   |            | 0.09689    |            |       |  0.03

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

Total # of neighbors = 217932
Ave neighs/atom = 54.483
Neighbor list builds = 4
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 = 333.520473540641, Press = -1.4072827542783
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -7807.0242     -7807.0242     -7978.5586     -7978.5586      331.84511      331.84511      124821.31      124821.31     -157.00313     -157.00313    
     27000  -7812.5723     -7812.5723     -7981.5214     -7981.5214      326.84356      326.84356      124850.09      124850.09     -563.05417     -563.05417    
Loop time of 306.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.282 ns/day, 85.001 hours/ns, 3.268 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    | 304.73     | 304.73     | 304.73     |   0.0 | 99.58
Neigh   | 0.17325    | 0.17325    | 0.17325    |   0.0 |  0.06
Comm    | 0.14559    | 0.14559    | 0.14559    |   0.0 |  0.05
Output  | 0.00024771 | 0.00024771 | 0.00024771 |   0.0 |  0.00
Modify  | 0.84856    | 0.84856    | 0.84856    |   0.0 |  0.28
Other   |            | 0.103      |            |       |  0.03

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

Total # of neighbors = 218172
Ave neighs/atom = 54.543
Neighbor list builds = 4
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 = 333.442296182461, Press = -0.804782308017721
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -7812.5723     -7812.5723     -7981.5214     -7981.5214      326.84356      326.84356      124850.09      124850.09     -563.05417     -563.05417    
     28000  -7810.7094     -7810.7094     -7982.5429     -7982.5429      332.42361      332.42361      124831.19      124831.19     -514.44267     -514.44267    
Loop time of 307.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.281 ns/day, 85.469 hours/ns, 3.250 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 306.43     | 306.43     | 306.43     |   0.0 | 99.59
Neigh   | 0.17292    | 0.17292    | 0.17292    |   0.0 |  0.06
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.05
Output  | 0.00027126 | 0.00027126 | 0.00027126 |   0.0 |  0.00
Modify  | 0.83923    | 0.83923    | 0.83923    |   0.0 |  0.27
Other   |            | 0.1024     |            |       |  0.03

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

Total # of neighbors = 218210
Ave neighs/atom = 54.5525
Neighbor list builds = 4
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 = 333.449302929032, Press = -1.17441382070907
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -7810.7094     -7810.7094     -7982.5429     -7982.5429      332.42361      332.42361      124831.19      124831.19     -514.44267     -514.44267    
     29000  -7806.2479     -7806.2479     -7980.9086     -7980.9086      337.89304      337.89304      124849.03      124849.03     -372.21149     -372.21149    
Loop time of 265.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.734 hours/ns, 3.767 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    | 264.36     | 264.36     | 264.36     |   0.0 | 99.59
Neigh   | 0.15692    | 0.15692    | 0.15692    |   0.0 |  0.06
Comm    | 0.12932    | 0.12932    | 0.12932    |   0.0 |  0.05
Output  | 0.0001914  | 0.0001914  | 0.0001914  |   0.0 |  0.00
Modify  | 0.69765    | 0.69765    | 0.69765    |   0.0 |  0.26
Other   |            | 0.09353    |            |       |  0.04

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

Total # of neighbors = 218246
Ave neighs/atom = 54.5615
Neighbor list builds = 4
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 = 333.397685788457, Press = -0.267975733792943
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -7806.2479     -7806.2479     -7980.9086     -7980.9086      337.89304      337.89304      124849.03      124849.03     -372.21149     -372.21149    
     30000  -7806.2318     -7806.2318     -7978.5571     -7978.5571      333.37509      333.37509      124837         124837        -254.85463     -254.85463    
Loop time of 259.236 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.010 hours/ns, 3.857 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    | 258.18     | 258.18     | 258.18     |   0.0 | 99.59
Neigh   | 0.15762    | 0.15762    | 0.15762    |   0.0 |  0.06
Comm    | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.05
Output  | 0.00023529 | 0.00023529 | 0.00023529 |   0.0 |  0.00
Modify  | 0.67204    | 0.67204    | 0.67204    |   0.0 |  0.26
Other   |            | 0.09367    |            |       |  0.04

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

Total # of neighbors = 218220
Ave neighs/atom = 54.555
Neighbor list builds = 4
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 = 333.366483958057, Press = 0.208060563412609
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -7806.2318     -7806.2318     -7978.5571     -7978.5571      333.37509      333.37509      124837         124837        -254.85463     -254.85463    
     31000  -7801.926      -7801.926      -7978.7955     -7978.7955      342.16601      342.16601      124767.03      124767.03      76.348007      76.348007    
Loop time of 258.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.334 ns/day, 71.940 hours/ns, 3.861 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    | 257.94     | 257.94     | 257.94     |   0.0 | 99.60
Neigh   | 0.15787    | 0.15787    | 0.15787    |   0.0 |  0.06
Comm    | 0.12702    | 0.12702    | 0.12702    |   0.0 |  0.05
Output  | 0.00019258 | 0.00019258 | 0.00019258 |   0.0 |  0.00
Modify  | 0.67014    | 0.67014    | 0.67014    |   0.0 |  0.26
Other   |            | 0.09284    |            |       |  0.04

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

Total # of neighbors = 217776
Ave neighs/atom = 54.444
Neighbor list builds = 4
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 = 333.394810566674, Press = 0.158419010495243
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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -7801.926      -7801.926      -7978.7955     -7978.7955      342.16601      342.16601      124767.03      124767.03      76.348007      76.348007    
     32000  -7806.4258     -7806.4258     -7977.2727     -7977.2727      330.51483      330.51483      124800.93      124800.93     -24.591603     -24.591603    
Loop time of 280.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.308 ns/day, 77.957 hours/ns, 3.563 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    | 279.49     | 279.49     | 279.49     |   0.0 | 99.59
Neigh   | 0.16512    | 0.16512    | 0.16512    |   0.0 |  0.06
Comm    | 0.13652    | 0.13652    | 0.13652    |   0.0 |  0.05
Output  | 0.00019036 | 0.00019036 | 0.00019036 |   0.0 |  0.00
Modify  | 0.7571     | 0.7571     | 0.7571     |   0.0 |  0.27
Other   |            | 0.09738    |            |       |  0.03

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

Total # of neighbors = 218012
Ave neighs/atom = 54.503
Neighbor list builds = 4
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
124756.037514915

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0