# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.619999974966049*${_u_distance}
variable latticeconst_converted equal 3.619999974966049*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61999997496605
Lattice spacing in x,y,z = 3.62 3.62 3.62
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Cu__MO_313717476091_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47437.9270158353 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 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_313717476091_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14008.467     -14008.467     -14160         -14160          293.15         293.15         47437.927      47437.927      3411.9444      3411.9444    
      1000  -13880.493     -13880.493     -14029.279     -14029.279      287.83596      287.83596      47851.295      47851.295     -643.07868     -643.07868    
Loop time of 193.029 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.619 hours/ns, 5.181 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    | 192.13     | 192.13     | 192.13     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14098    | 0.14098    | 0.14098    |   0.0 |  0.07
Output  | 0.00029509 | 0.00029509 | 0.00029509 |   0.0 |  0.00
Modify  | 0.65405    | 0.65405    | 0.65405    |   0.0 |  0.34
Other   |            | 0.0998     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.7      | 198.7      | 198.7      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13959    | 0.13959    | 0.13959    |   0.0 |  0.07
Output  | 0.00023607 | 0.00023607 | 0.00023607 |   0.0 |  0.00
Modify  | 0.64681    | 0.64681    | 0.64681    |   0.0 |  0.32
Other   |            | 0.09965    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.77     | 198.77     | 198.77     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14045    | 0.14045    | 0.14045    |   0.0 |  0.07
Output  | 0.00027979 | 0.00027979 | 0.00027979 |   0.0 |  0.00
Modify  | 0.64683    | 0.64683    | 0.64683    |   0.0 |  0.32
Other   |            | 0.09952    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.5      | 198.5      | 198.5      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13892    | 0.13892    | 0.13892    |   0.0 |  0.07
Output  | 0.00023633 | 0.00023633 | 0.00023633 |   0.0 |  0.00
Modify  | 0.6425     | 0.6425     | 0.6425     |   0.0 |  0.32
Other   |            | 0.1005     |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.317 hours/ns, 5.022 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.26     | 198.26     | 198.26     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13969    | 0.13969    | 0.13969    |   0.0 |  0.07
Output  | 0.00019531 | 0.00019531 | 0.00019531 |   0.0 |  0.00
Modify  | 0.64514    | 0.64514    | 0.64514    |   0.0 |  0.32
Other   |            | 0.09947    |            |       |  0.05

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

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

Performance: 0.434 ns/day, 55.264 hours/ns, 5.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.04     | 198.04     | 198.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13871    | 0.13871    | 0.13871    |   0.0 |  0.07
Output  | 0.00019403 | 0.00019403 | 0.00019403 |   0.0 |  0.00
Modify  | 0.66891    | 0.66891    | 0.66891    |   0.0 |  0.34
Other   |            | 0.09996    |            |       |  0.05

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

Total # of neighbors = 311626
Ave neighs/atom = 77.9065
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.050173705051, Press = 11.9831416406738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13874.758     -13874.758     -14025.019     -14025.019      290.68828      290.68828      47856.304      47856.304     -1342.5928     -1342.5928    
      7000  -13878.444     -13878.444     -14028.004     -14028.004      289.33489      289.33489      47763.696      47763.696      1398.5279      1398.5279    
Loop time of 199.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.357 hours/ns, 5.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.38     | 198.38     | 198.38     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14016    | 0.14016    | 0.14016    |   0.0 |  0.07
Output  | 0.0001945  | 0.0001945  | 0.0001945  |   0.0 |  0.00
Modify  | 0.66851    | 0.66851    | 0.66851    |   0.0 |  0.34
Other   |            | 0.09926    |            |       |  0.05

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

Total # of neighbors = 311580
Ave neighs/atom = 77.895
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.215343028548, Press = -22.1315164397945
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13878.444     -13878.444     -14028.004     -14028.004      289.33489      289.33489      47763.696      47763.696      1398.5279      1398.5279    
      8000  -13879.577     -13879.577     -14029.416     -14029.416      289.87393      289.87393      47833.127      47833.127     -482.88789     -482.88789    
Loop time of 199.717 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.81     | 198.81     | 198.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13989    | 0.13989    | 0.13989    |   0.0 |  0.07
Output  | 0.00019332 | 0.00019332 | 0.00019332 |   0.0 |  0.00
Modify  | 0.67133    | 0.67133    | 0.67133    |   0.0 |  0.34
Other   |            | 0.09782    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.65     | 199.65     | 199.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14445    | 0.14445    | 0.14445    |   0.0 |  0.07
Output  | 0.0001931  | 0.0001931  | 0.0001931  |   0.0 |  0.00
Modify  | 0.6724     | 0.6724     | 0.6724     |   0.0 |  0.34
Other   |            | 0.09582    |            |       |  0.05

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

Total # of neighbors = 311594
Ave neighs/atom = 77.8985
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.078853113989, Press = -11.7201947501434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13875.772     -13875.772     -14026.377     -14026.377      291.35495      291.35495      47805.381      47805.381      142.9385       142.9385     
     10000  -13873.411     -13873.411     -14025.915     -14025.915      295.02855      295.02855      47814.354      47814.354      17.918978      17.918978    
Loop time of 207.55 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.59     | 206.59     | 206.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14886    | 0.14886    | 0.14886    |   0.0 |  0.07
Output  | 0.0002532  | 0.0002532  | 0.0002532  |   0.0 |  0.00
Modify  | 0.71395    | 0.71395    | 0.71395    |   0.0 |  0.34
Other   |            | 0.1003     |            |       |  0.05

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

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

Performance: 0.432 ns/day, 55.537 hours/ns, 5.002 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    | 199.02     | 199.02     | 199.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14208    | 0.14208    | 0.14208    |   0.0 |  0.07
Output  | 0.00023869 | 0.00023869 | 0.00023869 |   0.0 |  0.00
Modify  | 0.67591    | 0.67591    | 0.67591    |   0.0 |  0.34
Other   |            | 0.09849    |            |       |  0.05

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

Total # of neighbors = 311496
Ave neighs/atom = 77.874
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.837143587769, Press = 0.788216365961676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13879.995     -13879.995     -14027.487     -14027.487      285.33403      285.33403      47808.072      47808.072     -120.37906     -120.37906    
     12000  -13877.386     -13877.386     -14025.918     -14025.918      287.34431      287.34431      47781.446      47781.446      696.7262       696.7262     
Loop time of 199.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.417 hours/ns, 5.013 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    | 198.59     | 198.59     | 198.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14124    | 0.14124    | 0.14124    |   0.0 |  0.07
Output  | 0.00019285 | 0.00019285 | 0.00019285 |   0.0 |  0.00
Modify  | 0.67367    | 0.67367    | 0.67367    |   0.0 |  0.34
Other   |            | 0.09892    |            |       |  0.05

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

Total # of neighbors = 311578
Ave neighs/atom = 77.8945
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.778438489169, Press = -10.5305520617221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13877.386     -13877.386     -14025.918     -14025.918      287.34431      287.34431      47781.446      47781.446      696.7262       696.7262     
     13000  -13874.404     -13874.404     -14027.563     -14027.563      296.29624      296.29624      47807.791      47807.791      17.540688      17.540688    
Loop time of 199.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.414 hours/ns, 5.013 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    | 198.58     | 198.58     | 198.58     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1419     | 0.1419     | 0.1419     |   0.0 |  0.07
Output  | 0.0001937  | 0.0001937  | 0.0001937  |   0.0 |  0.00
Modify  | 0.67168    | 0.67168    | 0.67168    |   0.0 |  0.34
Other   |            | 0.09853    |            |       |  0.05

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

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

Performance: 0.432 ns/day, 55.543 hours/ns, 5.001 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    | 199.04     | 199.04     | 199.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14181    | 0.14181    | 0.14181    |   0.0 |  0.07
Output  | 0.00051928 | 0.00051928 | 0.00051928 |   0.0 |  0.00
Modify  | 0.67419    | 0.67419    | 0.67419    |   0.0 |  0.34
Other   |            | 0.09894    |            |       |  0.05

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

Total # of neighbors = 311590
Ave neighs/atom = 77.8975
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.930741090992, Press = -5.48648733280343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13871.554     -13871.554     -14026.288     -14026.288      299.34419      299.34419      47828.741      47828.741     -217.02309     -217.02309    
     15000  -13877.368     -13877.368     -14026.685     -14026.685      288.86327      288.86327      47820.097      47820.097     -360.72334     -360.72334    
Loop time of 199.791 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.497 hours/ns, 5.005 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    | 198.88     | 198.88     | 198.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14141    | 0.14141    | 0.14141    |   0.0 |  0.07
Output  | 0.00023661 | 0.00023661 | 0.00023661 |   0.0 |  0.00
Modify  | 0.67451    | 0.67451    | 0.67451    |   0.0 |  0.34
Other   |            | 0.09847    |            |       |  0.05

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

Total # of neighbors = 311586
Ave neighs/atom = 77.8965
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.155365583626, Press = 2.19820219917509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13877.368     -13877.368     -14026.685     -14026.685      288.86327      288.86327      47820.097      47820.097     -360.72334     -360.72334    
     16000  -13880.067     -13880.067     -14028.84      -14028.84       287.81212      287.81212      47835.104      47835.104     -536.45256     -536.45256    
Loop time of 199.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.434 hours/ns, 5.011 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    | 198.65     | 198.65     | 198.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14191    | 0.14191    | 0.14191    |   0.0 |  0.07
Output  | 0.00019094 | 0.00019094 | 0.00019094 |   0.0 |  0.00
Modify  | 0.67354    | 0.67354    | 0.67354    |   0.0 |  0.34
Other   |            | 0.09883    |            |       |  0.05

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

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

Performance: 0.413 ns/day, 58.072 hours/ns, 4.783 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    | 208.09     | 208.09     | 208.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14805    | 0.14805    | 0.14805    |   0.0 |  0.07
Output  | 0.00019356 | 0.00019356 | 0.00019356 |   0.0 |  0.00
Modify  | 0.72044    | 0.72044    | 0.72044    |   0.0 |  0.34
Other   |            | 0.1019     |            |       |  0.05

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

Total # of neighbors = 311608
Ave neighs/atom = 77.902
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.144155402165, Press = 1.05779738236965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13874.671     -13874.671     -14027.424     -14027.424      295.51262      295.51262      47806.869      47806.869      258.1885       258.1885     
     18000  -13870.263     -13870.263     -14024.48      -14024.48       298.34263      298.34263      47849.701      47849.701     -1084.5816     -1084.5816    
Loop time of 200.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.772 hours/ns, 4.981 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    | 199.86     | 199.86     | 199.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14127    | 0.14127    | 0.14127    |   0.0 |  0.07
Output  | 0.00021259 | 0.00021259 | 0.00021259 |   0.0 |  0.00
Modify  | 0.67664    | 0.67664    | 0.67664    |   0.0 |  0.34
Other   |            | 0.09907    |            |       |  0.05

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

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

Performance: 0.367 ns/day, 65.436 hours/ns, 4.245 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    | 234.46     | 234.46     | 234.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16508    | 0.16508    | 0.16508    |   0.0 |  0.07
Output  | 0.00019474 | 0.00019474 | 0.00019474 |   0.0 |  0.00
Modify  | 0.83672    | 0.83672    | 0.83672    |   0.0 |  0.36
Other   |            | 0.1089     |            |       |  0.05

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

Total # of neighbors = 311442
Ave neighs/atom = 77.8605
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.214020591166, Press = 2.37485747627082
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13873.239     -13873.239     -14027.708     -14027.708      298.8308       298.8308       47730.261      47730.261      2224.3336      2224.3336    
     20000  -13878.52      -13878.52      -14029.062     -14029.062      291.23378      291.23378      47864.816      47864.816     -1459.5636     -1459.5636    
Loop time of 236.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.772 hours/ns, 4.223 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.67     | 235.67     | 235.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16549    | 0.16549    | 0.16549    |   0.0 |  0.07
Output  | 0.00026543 | 0.00026543 | 0.00026543 |   0.0 |  0.00
Modify  | 0.83644    | 0.83644    | 0.83644    |   0.0 |  0.35
Other   |            | 0.1078     |            |       |  0.05

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

Total # of neighbors = 311600
Ave neighs/atom = 77.9
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.136316083483, Press = -2.36481131619725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13878.52      -13878.52      -14029.062     -14029.062      291.23378      291.23378      47864.816      47864.816     -1459.5636     -1459.5636    
     21000  -13875.866     -13875.866     -14029.29      -14029.29       296.80793      296.80793      47755.63       47755.63       1435.3551      1435.3551    
Loop time of 236.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.723 hours/ns, 4.227 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.49     | 235.49     | 235.49     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16393    | 0.16393    | 0.16393    |   0.0 |  0.07
Output  | 0.00019638 | 0.00019638 | 0.00019638 |   0.0 |  0.00
Modify  | 0.83559    | 0.83559    | 0.83559    |   0.0 |  0.35
Other   |            | 0.1074     |            |       |  0.05

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

Total # of neighbors = 311564
Ave neighs/atom = 77.891
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.072079061041, Press = 0.220232680828304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13875.866     -13875.866     -14029.29      -14029.29       296.80793      296.80793      47755.63       47755.63       1435.3551      1435.3551    
     22000  -13874.785     -13874.785     -14025.458     -14025.458      291.4877       291.4877       47872.546      47872.546     -1690.2553     -1690.2553    
Loop time of 236.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.809 hours/ns, 4.221 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.8      | 235.8      | 235.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16465    | 0.16465    | 0.16465    |   0.0 |  0.07
Output  | 0.00019313 | 0.00019313 | 0.00019313 |   0.0 |  0.00
Modify  | 0.84049    | 0.84049    | 0.84049    |   0.0 |  0.35
Other   |            | 0.1083     |            |       |  0.05

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

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

Performance: 0.365 ns/day, 65.751 hours/ns, 4.225 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.57     | 235.57     | 235.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16689    | 0.16689    | 0.16689    |   0.0 |  0.07
Output  | 0.00024639 | 0.00024639 | 0.00024639 |   0.0 |  0.00
Modify  | 0.85787    | 0.85787    | 0.85787    |   0.0 |  0.36
Other   |            | 0.109      |            |       |  0.05

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

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

Performance: 0.365 ns/day, 65.748 hours/ns, 4.225 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.57     | 235.57     | 235.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16687    | 0.16687    | 0.16687    |   0.0 |  0.07
Output  | 0.00019303 | 0.00019303 | 0.00019303 |   0.0 |  0.00
Modify  | 0.84992    | 0.84992    | 0.84992    |   0.0 |  0.36
Other   |            | 0.1081     |            |       |  0.05

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

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

Performance: 0.385 ns/day, 62.367 hours/ns, 4.454 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    | 223.47     | 223.47     | 223.47     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15974    | 0.15974    | 0.15974    |   0.0 |  0.07
Output  | 0.00019235 | 0.00019235 | 0.00019235 |   0.0 |  0.00
Modify  | 0.79218    | 0.79218    | 0.79218    |   0.0 |  0.35
Other   |            | 0.1042     |            |       |  0.05

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

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

Performance: 0.394 ns/day, 60.855 hours/ns, 4.565 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    | 218.06     | 218.06     | 218.06     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15413    | 0.15413    | 0.15413    |   0.0 |  0.07
Output  | 0.00027018 | 0.00027018 | 0.00027018 |   0.0 |  0.00
Modify  | 0.75976    | 0.75976    | 0.75976    |   0.0 |  0.35
Other   |            | 0.1027     |            |       |  0.05

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

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

Performance: 0.367 ns/day, 65.458 hours/ns, 4.244 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    | 234.55     | 234.55     | 234.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16404    | 0.16404    | 0.16404    |   0.0 |  0.07
Output  | 0.00019384 | 0.00019384 | 0.00019384 |   0.0 |  0.00
Modify  | 0.83189    | 0.83189    | 0.83189    |   0.0 |  0.35
Other   |            | 0.1062     |            |       |  0.05

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

Total # of neighbors = 311582
Ave neighs/atom = 77.8955
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.278787383087, Press = -1.78017536832992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13876.227     -13876.227     -14025.449     -14025.449      288.68063      288.68063      47868.142      47868.142     -1635.0827     -1635.0827    
     28000  -13870.201     -13870.201     -14025.005     -14025.005      299.47925      299.47925      47761.626      47761.626      1668.1333      1668.1333    
Loop time of 235.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.483 hours/ns, 4.242 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    | 234.62     | 234.62     | 234.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16489    | 0.16489    | 0.16489    |   0.0 |  0.07
Output  | 0.00023303 | 0.00023303 | 0.00023303 |   0.0 |  0.00
Modify  | 0.84364    | 0.84364    | 0.84364    |   0.0 |  0.36
Other   |            | 0.1079     |            |       |  0.05

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

Total # of neighbors = 311516
Ave neighs/atom = 77.879
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.340870267734, Press = 0.289328197494911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13870.201     -13870.201     -14025.005     -14025.005      299.47925      299.47925      47761.626      47761.626      1668.1333      1668.1333    
     29000  -13874.809     -13874.809     -14026.711     -14026.711      293.86303      293.86303      47842.963      47842.963     -691.65709     -691.65709    
Loop time of 227.897 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.305 hours/ns, 4.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    | 226.82     | 226.82     | 226.82     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16032    | 0.16032    | 0.16032    |   0.0 |  0.07
Output  | 0.00019382 | 0.00019382 | 0.00019382 |   0.0 |  0.00
Modify  | 0.81497    | 0.81497    | 0.81497    |   0.0 |  0.36
Other   |            | 0.1068     |            |       |  0.05

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

Total # of neighbors = 311598
Ave neighs/atom = 77.8995
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.298565006075, Press = -0.828206914002657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13874.809     -13874.809     -14026.711     -14026.711      293.86303      293.86303      47842.963      47842.963     -691.65709     -691.65709    
     30000  -13878.215     -13878.215     -14029.662     -14029.662      292.98275      292.98275      47795.243      47795.243      535.74363      535.74363    
Loop time of 235.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.445 hours/ns, 4.244 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    | 234.47     | 234.47     | 234.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16495    | 0.16495    | 0.16495    |   0.0 |  0.07
Output  | 0.0001945  | 0.0001945  | 0.0001945  |   0.0 |  0.00
Modify  | 0.8569     | 0.8569     | 0.8569     |   0.0 |  0.36
Other   |            | 0.11       |            |       |  0.05

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

Total # of neighbors = 311546
Ave neighs/atom = 77.8865
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.216342970917, Press = -0.32284597210663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13878.215     -13878.215     -14029.662     -14029.662      292.98275      292.98275      47795.243      47795.243      535.74363      535.74363    
     31000  -13878.414     -13878.414     -14027.23      -14027.23       287.89339      287.89339      47829.348      47829.348     -515.42681     -515.42681    
Loop time of 236.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.601 hours/ns, 4.234 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    | 235.04     | 235.04     | 235.04     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16596    | 0.16596    | 0.16596    |   0.0 |  0.07
Output  | 0.00019526 | 0.00019526 | 0.00019526 |   0.0 |  0.00
Modify  | 0.84678    | 0.84678    | 0.84678    |   0.0 |  0.36
Other   |            | 0.11       |            |       |  0.05

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

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

Performance: 0.367 ns/day, 65.438 hours/ns, 4.245 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    | 234.42     | 234.42     | 234.42     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16734    | 0.16734    | 0.16734    |   0.0 |  0.07
Output  | 0.0003026  | 0.0003026  | 0.0003026  |   0.0 |  0.00
Modify  | 0.87242    | 0.87242    | 0.87242    |   0.0 |  0.37
Other   |            | 0.1127     |            |       |  0.05

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

Total # of neighbors = 311536
Ave neighs/atom = 77.884
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.177497991296, Press = -0.373641526055365
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13873.961     -13873.961     -14024.453     -14024.453      291.13627      291.13627      47765.432      47765.432      1195.7915      1195.7915    
     33000  -13872.93      -13872.93      -14025.568     -14025.568      295.28935      295.28935      47908.175      47908.175     -2681.4904     -2681.4904    
Loop time of 235.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.413 hours/ns, 4.247 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    | 234.36     | 234.36     | 234.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16557    | 0.16557    | 0.16557    |   0.0 |  0.07
Output  | 0.00025359 | 0.00025359 | 0.00025359 |   0.0 |  0.00
Modify  | 0.8531     | 0.8531     | 0.8531     |   0.0 |  0.36
Other   |            | 0.1097     |            |       |  0.05

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

Total # of neighbors = 311454
Ave neighs/atom = 77.8635
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.160219657605, Press = -0.569309344939148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13872.93      -13872.93      -14025.568     -14025.568      295.28935      295.28935      47908.175      47908.175     -2681.4904     -2681.4904    
     34000  -13877.644     -13877.644     -14026.665     -14026.665      288.29052      288.29052      47738.423      47738.423      2008.6008      2008.6008    
Loop time of 236.564 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.45     | 235.45     | 235.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16429    | 0.16429    | 0.16429    |   0.0 |  0.07
Output  | 0.00019399 | 0.00019399 | 0.00019399 |   0.0 |  0.00
Modify  | 0.84407    | 0.84407    | 0.84407    |   0.0 |  0.36
Other   |            | 0.1103     |            |       |  0.05

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

Total # of neighbors = 311444
Ave neighs/atom = 77.861
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.12477894271, Press = -0.679095428550659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13877.644     -13877.644     -14026.665     -14026.665      288.29052      288.29052      47738.423      47738.423      2008.6008      2008.6008    
     35000  -13876.001     -13876.001     -14027.353     -14027.353      292.80141      292.80141      47837.872      47837.872     -854.61297     -854.61297    
Loop time of 236.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.823 hours/ns, 4.220 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.83     | 235.83     | 235.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16663    | 0.16663    | 0.16663    |   0.0 |  0.07
Output  | 0.00019963 | 0.00019963 | 0.00019963 |   0.0 |  0.00
Modify  | 0.85602    | 0.85602    | 0.85602    |   0.0 |  0.36
Other   |            | 0.1101     |            |       |  0.05

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

Total # of neighbors = 311616
Ave neighs/atom = 77.904
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.173403820658, Press = 0.961393354823287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13876.001     -13876.001     -14027.353     -14027.353      292.80141      292.80141      47837.872      47837.872     -854.61297     -854.61297    
     36000  -13870.996     -13870.996     -14025.527     -14025.527      298.95055      298.95055      47795.753      47795.753      414.7787       414.7787     
Loop time of 231.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.298 hours/ns, 4.320 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    | 230.38     | 230.38     | 230.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16133    | 0.16133    | 0.16133    |   0.0 |  0.07
Output  | 0.00019161 | 0.00019161 | 0.00019161 |   0.0 |  0.00
Modify  | 0.81986    | 0.81986    | 0.81986    |   0.0 |  0.35
Other   |            | 0.1093     |            |       |  0.05

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

Total # of neighbors = 311548
Ave neighs/atom = 77.887
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.184337468306, Press = -0.705399295123401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13870.996     -13870.996     -14025.527     -14025.527      298.95055      298.95055      47795.753      47795.753      414.7787       414.7787     
     37000  -13873.294     -13873.294     -14027.579     -14027.579      298.47337      298.47337      47790.307      47790.307      672.41828      672.41828    
Loop time of 198.459 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.55     | 197.55     | 197.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13976    | 0.13976    | 0.13976    |   0.0 |  0.07
Output  | 0.00019277 | 0.00019277 | 0.00019277 |   0.0 |  0.00
Modify  | 0.66757    | 0.66757    | 0.66757    |   0.0 |  0.34
Other   |            | 0.09836    |            |       |  0.05

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

Total # of neighbors = 311598
Ave neighs/atom = 77.8995
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
47810.8967687729

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0