# 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.5213917642831802*${_u_distance}
variable latticeconst_converted equal 3.5213917642831802*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139176428318
Lattice spacing in x,y,z = 3.5213918 3.5213918 3.5213918
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213918 35.213918 35.213918)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.213918 35.213918 35.213918)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Ni

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

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


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

variable temp_converted equal 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_700541006254_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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17627.791     -17627.791     -17800         -17800          333.15         333.15         43665.962      43665.962      4212.4193      4212.4193    
      1000  -17444.252     -17444.252     -17614.792     -17614.792      329.92152      329.92152      44141.496      44141.496      100.79116      100.79116    
Loop time of 332.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.249 hours/ns, 3.011 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    | 331.17     | 331.17     | 331.17     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14593    | 0.14593    | 0.14593    |   0.0 |  0.04
Output  | 0.00024633 | 0.00024633 | 0.00024633 |   0.0 |  0.00
Modify  | 0.68123    | 0.68123    | 0.68123    |   0.0 |  0.21
Other   |            | 0.09784    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17444.252     -17444.252     -17614.792     -17614.792      329.92152      329.92152      44141.496      44141.496      100.79116      100.79116    
      2000  -17453.894     -17453.894     -17632.079     -17632.079      344.71128      344.71128      44157.033      44157.033     -1742.1524     -1742.1524    
Loop time of 357.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.350 hours/ns, 2.796 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    | 356.7      | 356.7      | 356.7      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15014    | 0.15014    | 0.15014    |   0.0 |  0.04
Output  | 0.00023253 | 0.00023253 | 0.00023253 |   0.0 |  0.00
Modify  | 0.70881    | 0.70881    | 0.70881    |   0.0 |  0.20
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 314638
Ave neighs/atom = 78.6595
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17453.894     -17453.894     -17632.079     -17632.079      344.71128      344.71128      44157.033      44157.033     -1742.1524     -1742.1524    
      3000  -17453.588     -17453.588     -17628.829     -17628.829      339.01654      339.01654      44123.429      44123.429     -68.615511     -68.615511    
Loop time of 334.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.973 hours/ns, 2.988 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.82     | 333.82     | 333.82     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14347    | 0.14347    | 0.14347    |   0.0 |  0.04
Output  | 0.00024609 | 0.00024609 | 0.00024609 |   0.0 |  0.00
Modify  | 0.64801    | 0.64801    | 0.64801    |   0.0 |  0.19
Other   |            | 0.09343    |            |       |  0.03

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

Total # of neighbors = 314440
Ave neighs/atom = 78.61
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17453.588     -17453.588     -17628.829     -17628.829      339.01654      339.01654      44123.429      44123.429     -68.615511     -68.615511    
      4000  -17451.01      -17451.01      -17622.251     -17622.251      331.27654      331.27654      44112.661      44112.661      755.32652      755.32652    
Loop time of 341.079 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.744 hours/ns, 2.932 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    | 340.17     | 340.17     | 340.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14643    | 0.14643    | 0.14643    |   0.0 |  0.04
Output  | 0.00023575 | 0.00023575 | 0.00023575 |   0.0 |  0.00
Modify  | 0.66947    | 0.66947    | 0.66947    |   0.0 |  0.20
Other   |            | 0.09624    |            |       |  0.03

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

Total # of neighbors = 314408
Ave neighs/atom = 78.602
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17451.01      -17451.01      -17622.251     -17622.251      331.27654      331.27654      44112.661      44112.661      755.32652      755.32652    
      5000  -17456.046     -17456.046     -17626.584     -17626.584      329.91743      329.91743      44123.225      44123.225     -33.466777     -33.466777    
Loop time of 359.205 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 358.23     | 358.23     | 358.23     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15025    | 0.15025    | 0.15025    |   0.0 |  0.04
Output  | 0.0002517  | 0.0002517  | 0.0002517  |   0.0 |  0.00
Modify  | 0.7223     | 0.7223     | 0.7223     |   0.0 |  0.20
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 314584
Ave neighs/atom = 78.646
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 = 331.438315070764, Press = -430.951646044379
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17456.046     -17456.046     -17626.584     -17626.584      329.91743      329.91743      44123.225      44123.225     -33.466777     -33.466777    
      6000  -17449.861     -17449.861     -17623.866     -17623.866      336.62574      336.62574      44165.308      44165.308     -1455.2134     -1455.2134    
Loop time of 379.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.477 hours/ns, 2.634 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.64     | 378.64     | 378.64     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15971    | 0.15971    | 0.15971    |   0.0 |  0.04
Output  | 0.00019855 | 0.00019855 | 0.00019855 |   0.0 |  0.00
Modify  | 0.81283    | 0.81283    | 0.81283    |   0.0 |  0.21
Other   |            | 0.1032     |            |       |  0.03

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

Total # of neighbors = 314486
Ave neighs/atom = 78.6215
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 = 332.706774661751, Press = -17.002986365501
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17449.861     -17449.861     -17623.866     -17623.866      336.62574      336.62574      44165.308      44165.308     -1455.2134     -1455.2134    
      7000  -17455.495     -17455.495     -17629.907     -17629.907      337.41273      337.41273      44116.513      44116.513      111.42302      111.42302    
Loop time of 333.051 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.514 hours/ns, 3.003 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.14     | 332.14     | 332.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14212    | 0.14212    | 0.14212    |   0.0 |  0.04
Output  | 0.00019914 | 0.00019914 | 0.00019914 |   0.0 |  0.00
Modify  | 0.67078    | 0.67078    | 0.67078    |   0.0 |  0.20
Other   |            | 0.09344    |            |       |  0.03

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

Total # of neighbors = 314520
Ave neighs/atom = 78.63
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 = 332.960509445816, Press = 21.6945372267532
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17455.495     -17455.495     -17629.907     -17629.907      337.41273      337.41273      44116.513      44116.513      111.42302      111.42302    
      8000  -17452.295     -17452.295     -17626.972     -17626.972      337.925        337.925        44059.458      44059.458      2717.2283      2717.2283    
Loop time of 333.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.645 hours/ns, 2.998 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.62     | 332.62     | 332.62     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14209    | 0.14209    | 0.14209    |   0.0 |  0.04
Output  | 0.00020007 | 0.00020007 | 0.00020007 |   0.0 |  0.00
Modify  | 0.67203    | 0.67203    | 0.67203    |   0.0 |  0.20
Other   |            | 0.09328    |            |       |  0.03

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

Total # of neighbors = 314430
Ave neighs/atom = 78.6075
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 = 332.864558786763, Press = -6.4190656658184
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17452.295     -17452.295     -17626.972     -17626.972      337.925        337.925        44059.458      44059.458      2717.2283      2717.2283    
      9000  -17459.039     -17459.039     -17627.731     -17627.731      326.34624      326.34624      44120.892      44120.892     -59.086437     -59.086437    
Loop time of 332.923 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.02     | 332.02     | 332.02     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14209    | 0.14209    | 0.14209    |   0.0 |  0.04
Output  | 0.00019927 | 0.00019927 | 0.00019927 |   0.0 |  0.00
Modify  | 0.67151    | 0.67151    | 0.67151    |   0.0 |  0.20
Other   |            | 0.09338    |            |       |  0.03

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

Total # of neighbors = 314602
Ave neighs/atom = 78.6505
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 = 332.369830325022, Press = -17.6868182446444
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17459.039     -17459.039     -17627.731     -17627.731      326.34624      326.34624      44120.892      44120.892     -59.086437     -59.086437    
     10000  -17454.306     -17454.306     -17627.407     -17627.407      334.87621      334.87621      44147.971      44147.971     -1062.1691     -1062.1691    
Loop time of 333.462 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.628 hours/ns, 2.999 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.55     | 332.55     | 332.55     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1424     | 0.1424     | 0.1424     |   0.0 |  0.04
Output  | 0.00024388 | 0.00024388 | 0.00024388 |   0.0 |  0.00
Modify  | 0.67079    | 0.67079    | 0.67079    |   0.0 |  0.20
Other   |            | 0.0944     |            |       |  0.03

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

Total # of neighbors = 314426
Ave neighs/atom = 78.6065
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 = 332.463990676494, Press = -3.53136396380676
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17454.306     -17454.306     -17627.407     -17627.407      334.87621      334.87621      44147.971      44147.971     -1062.1691     -1062.1691    
     11000  -17448.018     -17448.018     -17622.56      -17622.56       337.66352      337.66352      44129.114      44129.114      223.06897      223.06897    
Loop time of 333.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.711 hours/ns, 2.996 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.85     | 332.85     | 332.85     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14191    | 0.14191    | 0.14191    |   0.0 |  0.04
Output  | 0.00021571 | 0.00021571 | 0.00021571 |   0.0 |  0.00
Modify  | 0.6718     | 0.6718     | 0.6718     |   0.0 |  0.20
Other   |            | 0.09285    |            |       |  0.03

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

Total # of neighbors = 314370
Ave neighs/atom = 78.5925
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 = 332.749064454536, Press = -0.464564680255235
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17448.018     -17448.018     -17622.56      -17622.56       337.66352      337.66352      44129.114      44129.114      223.06897      223.06897    
     12000  -17454.231     -17454.231     -17626.775     -17626.775      333.79914      333.79914      44112.832      44112.832      523.49466      523.49466    
Loop time of 347.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.249 ns/day, 96.545 hours/ns, 2.877 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    | 346.6      | 346.6      | 346.6      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14603    | 0.14603    | 0.14603    |   0.0 |  0.04
Output  | 0.00019823 | 0.00019823 | 0.00019823 |   0.0 |  0.00
Modify  | 0.71295    | 0.71295    | 0.71295    |   0.0 |  0.21
Other   |            | 0.09866    |            |       |  0.03

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

Total # of neighbors = 314496
Ave neighs/atom = 78.624
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 = 332.971018545309, Press = -4.3004803683271
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17454.231     -17454.231     -17626.775     -17626.775      333.79914      333.79914      44112.832      44112.832      523.49466      523.49466    
     13000  -17449.311     -17449.311     -17621.745     -17621.745      333.58476      333.58476      44146.229      44146.229     -448.49213     -448.49213    
Loop time of 331.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.152 hours/ns, 3.014 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    | 330.84     | 330.84     | 330.84     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13981    | 0.13981    | 0.13981    |   0.0 |  0.04
Output  | 0.00019938 | 0.00019938 | 0.00019938 |   0.0 |  0.00
Modify  | 0.66942    | 0.66942    | 0.66942    |   0.0 |  0.20
Other   |            | 0.09609    |            |       |  0.03

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

Total # of neighbors = 314370
Ave neighs/atom = 78.5925
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 = 333.157005166924, Press = -3.73979966119428
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17449.311     -17449.311     -17621.745     -17621.745      333.58476      333.58476      44146.229      44146.229     -448.49213     -448.49213    
     14000  -17458.423     -17458.423     -17631.068     -17631.068      333.99364      333.99364      44132.2        44132.2       -714.97102     -714.97102    
Loop time of 332.148 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.263 hours/ns, 3.011 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.24     | 331.24     | 331.24     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13935    | 0.13935    | 0.13935    |   0.0 |  0.04
Output  | 0.00047528 | 0.00047528 | 0.00047528 |   0.0 |  0.00
Modify  | 0.66975    | 0.66975    | 0.66975    |   0.0 |  0.20
Other   |            | 0.09647    |            |       |  0.03

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

Total # of neighbors = 314394
Ave neighs/atom = 78.5985
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 = 333.126277971179, Press = -0.887704445972596
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17458.423     -17458.423     -17631.068     -17631.068      333.99364      333.99364      44132.2        44132.2       -714.97102     -714.97102    
     15000  -17452.394     -17452.394     -17624.918     -17624.918      333.75885      333.75885      44105.774      44105.774      951.348        951.348      
Loop time of 331.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.122 hours/ns, 3.015 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.73     | 330.73     | 330.73     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14009    | 0.14009    | 0.14009    |   0.0 |  0.04
Output  | 0.00019797 | 0.00019797 | 0.00019797 |   0.0 |  0.00
Modify  | 0.66876    | 0.66876    | 0.66876    |   0.0 |  0.20
Other   |            | 0.09644    |            |       |  0.03

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

Total # of neighbors = 314370
Ave neighs/atom = 78.5925
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 = 332.911134419847, Press = -0.445427929081777
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17452.394     -17452.394     -17624.918     -17624.918      333.75885      333.75885      44105.774      44105.774      951.348        951.348      
     16000  -17455.614     -17455.614     -17628.392     -17628.392      334.25082      334.25082      44106.919      44106.919      662.33833      662.33833    
Loop time of 332.061 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.239 hours/ns, 3.011 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.15     | 331.15     | 331.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14017    | 0.14017    | 0.14017    |   0.0 |  0.04
Output  | 0.00024268 | 0.00024268 | 0.00024268 |   0.0 |  0.00
Modify  | 0.66895    | 0.66895    | 0.66895    |   0.0 |  0.20
Other   |            | 0.09681    |            |       |  0.03

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

Total # of neighbors = 314544
Ave neighs/atom = 78.636
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 = 332.917872499634, Press = -5.69393542478964
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17455.614     -17455.614     -17628.392     -17628.392      334.25082      334.25082      44106.919      44106.919      662.33833      662.33833    
     17000  -17451.379     -17451.379     -17624.633     -17624.633      335.1715       335.1715       44182.339      44182.339     -2247.5472     -2247.5472    
Loop time of 332.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.299 hours/ns, 3.010 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.37     | 331.37     | 331.37     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13957    | 0.13957    | 0.13957    |   0.0 |  0.04
Output  | 0.00019917 | 0.00019917 | 0.00019917 |   0.0 |  0.00
Modify  | 0.66945    | 0.66945    | 0.66945    |   0.0 |  0.20
Other   |            | 0.0962     |            |       |  0.03

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

Total # of neighbors = 314426
Ave neighs/atom = 78.6065
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 = 332.917918032127, Press = -4.01938257750425
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17451.379     -17451.379     -17624.633     -17624.633      335.1715       335.1715       44182.339      44182.339     -2247.5472     -2247.5472    
     18000  -17448.582     -17448.582     -17620.757     -17620.757      333.08402      333.08402      44157.72       44157.72      -754.7191      -754.7191     
Loop time of 332.012 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.226 hours/ns, 3.012 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.11     | 331.11     | 331.11     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13821    | 0.13821    | 0.13821    |   0.0 |  0.04
Output  | 0.00019853 | 0.00019853 | 0.00019853 |   0.0 |  0.00
Modify  | 0.67258    | 0.67258    | 0.67258    |   0.0 |  0.20
Other   |            | 0.09629    |            |       |  0.03

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

Total # of neighbors = 314390
Ave neighs/atom = 78.5975
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 = 333.021403267806, Press = 2.7441995533106
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17448.582     -17448.582     -17620.757     -17620.757      333.08402      333.08402      44157.72       44157.72      -754.7191      -754.7191     
     19000  -17454.297     -17454.297     -17627.597     -17627.597      335.26114      335.26114      44086.206      44086.206      1570.8985      1570.8985    
Loop time of 332.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.286 hours/ns, 3.010 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.32     | 331.32     | 331.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13816    | 0.13816    | 0.13816    |   0.0 |  0.04
Output  | 0.00019744 | 0.00019744 | 0.00019744 |   0.0 |  0.00
Modify  | 0.67356    | 0.67356    | 0.67356    |   0.0 |  0.20
Other   |            | 0.09595    |            |       |  0.03

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

Total # of neighbors = 314416
Ave neighs/atom = 78.604
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 = 333.120503392241, Press = 0.75236917208251
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17454.297     -17454.297     -17627.597     -17627.597      335.26114      335.26114      44086.206      44086.206      1570.8985      1570.8985    
     20000  -17449.645     -17449.645     -17624.56      -17624.56       338.3843       338.3843       44115.06       44115.06       601.21589      601.21589    
Loop time of 332.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.238 hours/ns, 3.012 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.15     | 331.15     | 331.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1392     | 0.1392     | 0.1392     |   0.0 |  0.04
Output  | 0.00019747 | 0.00019747 | 0.00019747 |   0.0 |  0.00
Modify  | 0.67231    | 0.67231    | 0.67231    |   0.0 |  0.20
Other   |            | 0.0969     |            |       |  0.03

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

Total # of neighbors = 314484
Ave neighs/atom = 78.621
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 = 333.228000466252, Press = -3.64593219672695
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17449.645     -17449.645     -17624.56      -17624.56       338.3843       338.3843       44115.06       44115.06       601.21589      601.21589    
     21000  -17455.481     -17455.481     -17626.651     -17626.651      331.14126      331.14126      44158.479      44158.479     -1519.9508     -1519.9508    
Loop time of 331.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.086 hours/ns, 3.017 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.6      | 330.6      | 330.6      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13908    | 0.13908    | 0.13908    |   0.0 |  0.04
Output  | 0.00019719 | 0.00019719 | 0.00019719 |   0.0 |  0.00
Modify  | 0.66966    | 0.66966    | 0.66966    |   0.0 |  0.20
Other   |            | 0.09474    |            |       |  0.03

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

Total # of neighbors = 314530
Ave neighs/atom = 78.6325
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 = 333.314971239125, Press = -2.5304388529051
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17455.481     -17455.481     -17626.651     -17626.651      331.14126      331.14126      44158.479      44158.479     -1519.9508     -1519.9508    
     22000  -17450.732     -17450.732     -17623.711     -17623.711      334.63863      334.63863      44144.342      44144.342     -635.45358     -635.45358    
Loop time of 330.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.922 hours/ns, 3.022 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.02     | 330.02     | 330.02     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13948    | 0.13948    | 0.13948    |   0.0 |  0.04
Output  | 0.00019911 | 0.00019911 | 0.00019911 |   0.0 |  0.00
Modify  | 0.66958    | 0.66958    | 0.66958    |   0.0 |  0.20
Other   |            | 0.09404    |            |       |  0.03

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

Total # of neighbors = 314396
Ave neighs/atom = 78.599
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 = 333.391273148318, Press = 1.67034953245135
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17450.732     -17450.732     -17623.711     -17623.711      334.63863      334.63863      44144.342      44144.342     -635.45358     -635.45358    
     23000  -17451.807     -17451.807     -17625.205     -17625.205      335.45032      335.45032      44080.129      44080.129      2000.9023      2000.9023    
Loop time of 331.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.065 hours/ns, 3.017 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.53     | 330.53     | 330.53     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13806    | 0.13806    | 0.13806    |   0.0 |  0.04
Output  | 0.00019642 | 0.00019642 | 0.00019642 |   0.0 |  0.00
Modify  | 0.66964    | 0.66964    | 0.66964    |   0.0 |  0.20
Other   |            | 0.09497    |            |       |  0.03

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

Total # of neighbors = 314364
Ave neighs/atom = 78.591
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 = 333.355914262033, Press = -0.089980211962545
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17451.807     -17451.807     -17625.205     -17625.205      335.45032      335.45032      44080.129      44080.129      2000.9023      2000.9023    
     24000  -17456.568     -17456.568     -17628.186     -17628.186      332.00526      332.00526      44101.286      44101.286      729.44835      729.44835    
Loop time of 330.999 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.944 hours/ns, 3.021 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    | 330.09     | 330.09     | 330.09     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13855    | 0.13855    | 0.13855    |   0.0 |  0.04
Output  | 0.00019733 | 0.00019733 | 0.00019733 |   0.0 |  0.00
Modify  | 0.67033    | 0.67033    | 0.67033    |   0.0 |  0.20
Other   |            | 0.09488    |            |       |  0.03

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

Total # of neighbors = 314472
Ave neighs/atom = 78.618
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 = 333.353471023173, Press = -4.9321367452731
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17456.568     -17456.568     -17628.186     -17628.186      332.00526      332.00526      44101.286      44101.286      729.44835      729.44835    
     25000  -17452.394     -17452.394     -17623.379     -17623.379      330.78258      330.78258      44215.41       44215.41      -3569.6305     -3569.6305    
Loop time of 374.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.974 hours/ns, 2.672 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    | 373.26     | 373.26     | 373.26     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15313    | 0.15313    | 0.15313    |   0.0 |  0.04
Output  | 0.00019758 | 0.00019758 | 0.00019758 |   0.0 |  0.00
Modify  | 0.79317    | 0.79317    | 0.79317    |   0.0 |  0.21
Other   |            | 0.1031     |            |       |  0.03

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

Total # of neighbors = 314470
Ave neighs/atom = 78.6175
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 = 333.336011850563, Press = -3.38524232653792
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17452.394     -17452.394     -17623.379     -17623.379      330.78258      330.78258      44215.41       44215.41      -3569.6305     -3569.6305    
     26000  -17457.104     -17457.104     -17626.647     -17626.647      327.993        327.993        44135.79       44135.79      -558.42091     -558.42091    
Loop time of 331.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.112 hours/ns, 3.016 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.7      | 330.7      | 330.7      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13881    | 0.13881    | 0.13881    |   0.0 |  0.04
Output  | 0.00020022 | 0.00020022 | 0.00020022 |   0.0 |  0.00
Modify  | 0.66827    | 0.66827    | 0.66827    |   0.0 |  0.20
Other   |            | 0.09478    |            |       |  0.03

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

Total # of neighbors = 314276
Ave neighs/atom = 78.569
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 = 333.31043952116, Press = 1.0121431599534
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17457.104     -17457.104     -17626.647     -17626.647      327.993        327.993        44135.79       44135.79      -558.42091     -558.42091    
     27000  -17450.845     -17450.845     -17624.834     -17624.834      336.59416      336.59416      44101.987      44101.987      1147.4358      1147.4358    
Loop time of 331.87 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.186 hours/ns, 3.013 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 330.97     | 330.97     | 330.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13892    | 0.13892    | 0.13892    |   0.0 |  0.04
Output  | 0.00019935 | 0.00019935 | 0.00019935 |   0.0 |  0.00
Modify  | 0.66945    | 0.66945    | 0.66945    |   0.0 |  0.20
Other   |            | 0.0947     |            |       |  0.03

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

Total # of neighbors = 314416
Ave neighs/atom = 78.604
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
44127.0263207661

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0