# 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.962      43665.962      3453.7659      3453.7659    
      1000  -17508.971     -17508.971     -17649.434     -17649.434      271.73443      271.73443      44083.462      44083.462     -1169.063      -1169.063     
Loop time of 318.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.271 ns/day, 88.510 hours/ns, 3.138 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    | 317.74     | 317.74     | 317.74     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14403    | 0.14403    | 0.14403    |   0.0 |  0.05
Output  | 0.000238   | 0.000238   | 0.000238   |   0.0 |  0.00
Modify  | 0.65512    | 0.65512    | 0.65512    |   0.0 |  0.21
Other   |            | 0.09789    |            |       |  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  -17508.971     -17508.971     -17649.434     -17649.434      271.73443      271.73443      44083.462      44083.462     -1169.063      -1169.063     
      2000  -17516.528     -17516.528     -17662.124     -17662.124      281.66505      281.66505      44038.279      44038.279     -153.17184     -153.17184    
Loop time of 347.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.248 ns/day, 96.644 hours/ns, 2.874 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.97     | 346.97     | 346.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15194    | 0.15194    | 0.15194    |   0.0 |  0.04
Output  | 0.00022814 | 0.00022814 | 0.00022814 |   0.0 |  0.00
Modify  | 0.69808    | 0.69808    | 0.69808    |   0.0 |  0.20
Other   |            | 0.09942    |            |       |  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:       314136 ave      314136 max      314136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314136
Ave neighs/atom = 78.534
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  -17516.528     -17516.528     -17662.124     -17662.124      281.66505      281.66505      44038.279      44038.279     -153.17184     -153.17184    
      3000  -17516.778     -17516.778     -17657.765     -17657.765      272.74969      272.74969      44026.265      44026.265      650.90516      650.90516    
Loop time of 333.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.651 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.65     | 332.65     | 332.65     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14313    | 0.14313    | 0.14313    |   0.0 |  0.04
Output  | 0.0003455  | 0.0003455  | 0.0003455  |   0.0 |  0.00
Modify  | 0.65519    | 0.65519    | 0.65519    |   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:       314152 ave      314152 max      314152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314152
Ave neighs/atom = 78.538
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  -17516.778     -17516.778     -17657.765     -17657.765      272.74969      272.74969      44026.265      44026.265      650.90516      650.90516    
      4000  -17514.183     -17514.183     -17651.621     -17651.621      265.88268      265.88268      44055.409      44055.409     -143.57786     -143.57786    
Loop time of 336.009 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.336 hours/ns, 2.976 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    | 335.11     | 335.11     | 335.11     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14411    | 0.14411    | 0.14411    |   0.0 |  0.04
Output  | 0.00027859 | 0.00027859 | 0.00027859 |   0.0 |  0.00
Modify  | 0.66278    | 0.66278    | 0.66278    |   0.0 |  0.20
Other   |            | 0.09651    |            |       |  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:       314056 ave      314056 max      314056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314056
Ave neighs/atom = 78.514
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  -17514.183     -17514.183     -17651.621     -17651.621      265.88268      265.88268      44055.409      44055.409     -143.57786     -143.57786    
      5000  -17518.467     -17518.467     -17658.42      -17658.42       270.74738      270.74738      44030.729      44030.729      441.09315      441.09315    
Loop time of 329.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.643 hours/ns, 3.031 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    | 329.03     | 329.03     | 329.03     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14201    | 0.14201    | 0.14201    |   0.0 |  0.04
Output  | 0.0001917  | 0.0001917  | 0.0001917  |   0.0 |  0.00
Modify  | 0.64716    | 0.64716    | 0.64716    |   0.0 |  0.20
Other   |            | 0.09586    |            |       |  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:       314204 ave      314204 max      314204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314204
Ave neighs/atom = 78.551
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 = 271.212812074656, Press = -265.065142885898
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  -17518.467     -17518.467     -17658.42      -17658.42       270.74738      270.74738      44030.729      44030.729      441.09315      441.09315    
      6000  -17513.288     -17513.288     -17656.062     -17656.062      276.20463      276.20463      44043.175      44043.175      70.40067       70.40067     
Loop time of 360.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.226 hours/ns, 2.772 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    | 359.8      | 359.8      | 359.8      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15312    | 0.15312    | 0.15312    |   0.0 |  0.04
Output  | 0.00019031 | 0.00019031 | 0.00019031 |   0.0 |  0.00
Modify  | 0.75541    | 0.75541    | 0.75541    |   0.0 |  0.21
Other   |            | 0.1015     |            |       |  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:       314052 ave      314052 max      314052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314052
Ave neighs/atom = 78.513
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 = 272.836228962584, Press = 12.0351088145752
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  -17513.288     -17513.288     -17656.062     -17656.062      276.20463      276.20463      44043.175      44043.175      70.40067       70.40067     
      7000  -17517.755     -17517.755     -17657.033     -17657.033      269.44349      269.44349      44077.84       44077.84      -1536.2251     -1536.2251    
Loop time of 346.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.249 ns/day, 96.387 hours/ns, 2.882 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.02     | 346.02     | 346.02     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15309    | 0.15309    | 0.15309    |   0.0 |  0.04
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.72252    | 0.72252    | 0.72252    |   0.0 |  0.21
Other   |            | 0.09675    |            |       |  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:       314186 ave      314186 max      314186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314186
Ave neighs/atom = 78.5465
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 = 272.990442415734, Press = -21.193852277794
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  -17517.755     -17517.755     -17657.033     -17657.033      269.44349      269.44349      44077.84       44077.84      -1536.2251     -1536.2251    
      8000  -17515.635     -17515.635     -17656.184     -17656.184      271.90232      271.90232      43983.143      43983.143      2566.6832      2566.6832    
Loop time of 329.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.463 hours/ns, 3.037 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    | 328.36     | 328.36     | 328.36     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14341    | 0.14341    | 0.14341    |   0.0 |  0.04
Output  | 0.00019258 | 0.00019258 | 0.00019258 |   0.0 |  0.00
Modify  | 0.66936    | 0.66936    | 0.66936    |   0.0 |  0.20
Other   |            | 0.0933     |            |       |  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:       313968 ave      313968 max      313968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313968
Ave neighs/atom = 78.492
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 = 272.892055003866, Press = -7.11795384445911
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  -17515.635     -17515.635     -17656.184     -17656.184      271.90232      271.90232      43983.143      43983.143      2566.6832      2566.6832    
      9000  -17521.29      -17521.29      -17659.323     -17659.323      267.0347       267.0347       44056.66       44056.66      -855.75198     -855.75198    
Loop time of 329.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.449 hours/ns, 3.038 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    | 328.31     | 328.31     | 328.31     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14288    | 0.14288    | 0.14288    |   0.0 |  0.04
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.66862    | 0.66862    | 0.66862    |   0.0 |  0.20
Other   |            | 0.09427    |            |       |  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:       314168 ave      314168 max      314168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314168
Ave neighs/atom = 78.542
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 = 272.451852888603, Press = 6.15507822515683
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  -17521.29      -17521.29      -17659.323     -17659.323      267.0347       267.0347       44056.66       44056.66      -855.75198     -855.75198    
     10000  -17514.946     -17514.946     -17656.229     -17656.229      273.32104      273.32104      44048.45       44048.45      -183.94571     -183.94571    
Loop time of 329.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.467 hours/ns, 3.037 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    | 328.37     | 328.37     | 328.37     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14367    | 0.14367    | 0.14367    |   0.0 |  0.04
Output  | 0.00019171 | 0.00019171 | 0.00019171 |   0.0 |  0.00
Modify  | 0.66852    | 0.66852    | 0.66852    |   0.0 |  0.20
Other   |            | 0.09622    |            |       |  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:       313904 ave      313904 max      313904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313904
Ave neighs/atom = 78.476
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 = 272.451610729613, Press = -7.46109428837584
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  -17514.946     -17514.946     -17656.229     -17656.229      273.32104      273.32104      44048.45       44048.45      -183.94571     -183.94571    
     11000  -17516.833     -17516.833     -17656.533     -17656.533      270.25901      270.25901      44030.718      44030.718      558.34081      558.34081    
Loop time of 329.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.503 hours/ns, 3.036 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    | 328.5      | 328.5      | 328.5      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14271    | 0.14271    | 0.14271    |   0.0 |  0.04
Output  | 0.00019386 | 0.00019386 | 0.00019386 |   0.0 |  0.00
Modify  | 0.67038    | 0.67038    | 0.67038    |   0.0 |  0.20
Other   |            | 0.09561    |            |       |  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:       314062 ave      314062 max      314062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314062
Ave neighs/atom = 78.5155
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 = 272.51194113723, Press = -1.03532873774833
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  -17516.833     -17516.833     -17656.533     -17656.533      270.25901      270.25901      44030.718      44030.718      558.34081      558.34081    
     12000  -17512.882     -17512.882     -17652.608     -17652.608      270.3099       270.3099       44054.71       44054.71      -163.55712     -163.55712    
Loop time of 330.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.929 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.03     | 330.03     | 330.03     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14618    | 0.14618    | 0.14618    |   0.0 |  0.04
Output  | 0.00019515 | 0.00019515 | 0.00019515 |   0.0 |  0.00
Modify  | 0.67315    | 0.67315    | 0.67315    |   0.0 |  0.20
Other   |            | 0.09461    |            |       |  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:       314064 ave      314064 max      314064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314064
Ave neighs/atom = 78.516
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 = 272.68729959789, Press = -1.98126657677201
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  -17512.882     -17512.882     -17652.608     -17652.608      270.3099       270.3099       44054.71       44054.71      -163.55712     -163.55712    
     13000  -17516.215     -17516.215     -17657.89      -17657.89       274.08054      274.08054      44043.543      44043.543     -55.573407     -55.573407    
Loop time of 330.446 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.791 hours/ns, 3.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    | 329.53     | 329.53     | 329.53     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14288    | 0.14288    | 0.14288    |   0.0 |  0.04
Output  | 0.00023756 | 0.00023756 | 0.00023756 |   0.0 |  0.00
Modify  | 0.67284    | 0.67284    | 0.67284    |   0.0 |  0.20
Other   |            | 0.09535    |            |       |  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:       314068 ave      314068 max      314068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314068
Ave neighs/atom = 78.517
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 = 272.806110315365, Press = -5.73985510988353
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  -17516.215     -17516.215     -17657.89      -17657.89       274.08054      274.08054      44043.543      44043.543     -55.573407     -55.573407    
     14000  -17512.915     -17512.915     -17655.635     -17655.635      276.10185      276.10185      44012.035      44012.035      1484.3943      1484.3943    
Loop time of 329.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.571 hours/ns, 3.033 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    | 328.75     | 328.75     | 328.75     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14308    | 0.14308    | 0.14308    |   0.0 |  0.04
Output  | 0.00042367 | 0.00042367 | 0.00042367 |   0.0 |  0.00
Modify  | 0.67124    | 0.67124    | 0.67124    |   0.0 |  0.20
Other   |            | 0.09462    |            |       |  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:       313962 ave      313962 max      313962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313962
Ave neighs/atom = 78.4905
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 = 272.969387630628, Press = 1.32234737132539
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  -17512.915     -17512.915     -17655.635     -17655.635      276.10185      276.10185      44012.035      44012.035      1484.3943      1484.3943    
     15000  -17516.076     -17516.076     -17654.811     -17654.811      268.39172      268.39172      44085.447      44085.447     -1632.2772     -1632.2772    
Loop time of 329.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.596 hours/ns, 3.033 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    | 328.83     | 328.83     | 328.83     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14303    | 0.14303    | 0.14303    |   0.0 |  0.04
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.67204    | 0.67204    | 0.67204    |   0.0 |  0.20
Other   |            | 0.09482    |            |       |  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:       314130 ave      314130 max      314130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314130
Ave neighs/atom = 78.5325
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 = 272.857977951566, Press = -0.258299040177159
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  -17516.076     -17516.076     -17654.811     -17654.811      268.39172      268.39172      44085.447      44085.447     -1632.2772     -1632.2772    
     16000  -17519.431     -17519.431     -17660.145     -17660.145      272.22188      272.22188      44017.209      44017.209      823.03131      823.03131    
Loop time of 330.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.748 hours/ns, 3.028 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    | 329.38     | 329.38     | 329.38     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14226    | 0.14226    | 0.14226    |   0.0 |  0.04
Output  | 0.00023799 | 0.00023799 | 0.00023799 |   0.0 |  0.00
Modify  | 0.67191    | 0.67191    | 0.67191    |   0.0 |  0.20
Other   |            | 0.09515    |            |       |  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:       313966 ave      313966 max      313966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313966
Ave neighs/atom = 78.4915
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 = 272.827700376707, Press = -4.88495278985212
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  -17519.431     -17519.431     -17660.145     -17660.145      272.22188      272.22188      44017.209      44017.209      823.03131      823.03131    
     17000  -17512.918     -17512.918     -17655.685     -17655.685      276.19205      276.19205      44030.213      44030.213      748.24926      748.24926    
Loop time of 330.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.692 hours/ns, 3.029 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    | 329.18     | 329.18     | 329.18     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14233    | 0.14233    | 0.14233    |   0.0 |  0.04
Output  | 0.00019311 | 0.00019311 | 0.00019311 |   0.0 |  0.00
Modify  | 0.67233    | 0.67233    | 0.67233    |   0.0 |  0.20
Other   |            | 0.09606    |            |       |  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:       314008 ave      314008 max      314008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314008
Ave neighs/atom = 78.502
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 = 272.746465279472, Press = 1.4098487133142
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  -17512.918     -17512.918     -17655.685     -17655.685      276.19205      276.19205      44030.213      44030.213      748.24926      748.24926    
     18000  -17519.702     -17519.702     -17659.645     -17659.645      270.72936      270.72936      44065.133      44065.133     -1110.6287     -1110.6287    
Loop time of 329.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.529 hours/ns, 3.035 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    | 328.6      | 328.6      | 328.6      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14245    | 0.14245    | 0.14245    |   0.0 |  0.04
Output  | 0.00019041 | 0.00019041 | 0.00019041 |   0.0 |  0.00
Modify  | 0.67131    | 0.67131    | 0.67131    |   0.0 |  0.20
Other   |            | 0.09496    |            |       |  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:       314078 ave      314078 max      314078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314078
Ave neighs/atom = 78.5195
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 = 272.726323745771, Press = -1.85519200344602
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  -17519.702     -17519.702     -17659.645     -17659.645      270.72936      270.72936      44065.133      44065.133     -1110.6287     -1110.6287    
     19000  -17514.79      -17514.79      -17656.208     -17656.208      273.58213      273.58213      44035.223      44035.223      442.68556      442.68556    
Loop time of 328.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.276 hours/ns, 3.043 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    | 327.69     | 327.69     | 327.69     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13996    | 0.13996    | 0.13996    |   0.0 |  0.04
Output  | 0.00019368 | 0.00019368 | 0.00019368 |   0.0 |  0.00
Modify  | 0.67046    | 0.67046    | 0.67046    |   0.0 |  0.20
Other   |            | 0.09511    |            |       |  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:       313802 ave      313802 max      313802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313802
Ave neighs/atom = 78.4505
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 = 272.652073768655, Press = -1.78043156540398
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  -17514.79      -17514.79      -17656.208     -17656.208      273.58213      273.58213      44035.223      44035.223      442.68556      442.68556    
     20000  -17522.883     -17522.883     -17658.878     -17658.878      263.09134      263.09134      44034.682      44034.682      9.8255149      9.8255149    
Loop time of 328.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.323 hours/ns, 3.042 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    | 327.86     | 327.86     | 327.86     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14151    | 0.14151    | 0.14151    |   0.0 |  0.04
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.66832    | 0.66832    | 0.66832    |   0.0 |  0.20
Other   |            | 0.09546    |            |       |  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:       314100 ave      314100 max      314100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314100
Ave neighs/atom = 78.525
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 = 272.596998239418, Press = -0.378986304679043
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  -17522.883     -17522.883     -17658.878     -17658.878      263.09134      263.09134      44034.682      44034.682      9.8255149      9.8255149    
     21000  -17512.89      -17512.89      -17657.679     -17657.679      280.10358      280.10358      44057.752      44057.752     -554.269       -554.269      
Loop time of 328.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.314 hours/ns, 3.042 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    | 327.82     | 327.82     | 327.82     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14068    | 0.14068    | 0.14068    |   0.0 |  0.04
Output  | 0.00019143 | 0.00019143 | 0.00019143 |   0.0 |  0.00
Modify  | 0.66953    | 0.66953    | 0.66953    |   0.0 |  0.20
Other   |            | 0.09482    |            |       |  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:       314028 ave      314028 max      314028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314028
Ave neighs/atom = 78.507
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 = 272.58053098379, Press = -2.40922025449915
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  -17512.89      -17512.89      -17657.679     -17657.679      280.10358      280.10358      44057.752      44057.752     -554.269       -554.269      
     22000  -17519.04      -17519.04      -17660.454     -17660.454      273.57589      273.57589      43998.834      43998.834      1551.794       1551.794     
Loop time of 328.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.254 hours/ns, 3.044 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    | 327.61     | 327.61     | 327.61     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14134    | 0.14134    | 0.14134    |   0.0 |  0.04
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.66921    | 0.66921    | 0.66921    |   0.0 |  0.20
Other   |            | 0.09491    |            |       |  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:       313970 ave      313970 max      313970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313970
Ave neighs/atom = 78.4925
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 = 272.600795660982, Press = -0.661348051641695
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  -17519.04      -17519.04      -17660.454     -17660.454      273.57589      273.57589      43998.834      43998.834      1551.794       1551.794     
     23000  -17513.267     -17513.267     -17654.707     -17654.707      273.6258       273.6258       44079.194      44079.194     -1299.3118     -1299.3118    
Loop time of 328.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.296 hours/ns, 3.043 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    | 327.76     | 327.76     | 327.76     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14046    | 0.14046    | 0.14046    |   0.0 |  0.04
Output  | 0.00019288 | 0.00019288 | 0.00019288 |   0.0 |  0.00
Modify  | 0.66914    | 0.66914    | 0.66914    |   0.0 |  0.20
Other   |            | 0.0951     |            |       |  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:       314114 ave      314114 max      314114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314114
Ave neighs/atom = 78.5285
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 = 272.688707648194, Press = 0.972663355591918
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  -17513.267     -17513.267     -17654.707     -17654.707      273.6258       273.6258       44079.194      44079.194     -1299.3118     -1299.3118    
     24000  -17517.928     -17517.928     -17657.306     -17657.306      269.63557      269.63557      44043.954      44043.954     -148.55873     -148.55873    
Loop time of 328.806 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.335 hours/ns, 3.041 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    | 327.9      | 327.9      | 327.9      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14048    | 0.14048    | 0.14048    |   0.0 |  0.04
Output  | 0.00019309 | 0.00019309 | 0.00019309 |   0.0 |  0.00
Modify  | 0.66955    | 0.66955    | 0.66955    |   0.0 |  0.20
Other   |            | 0.09535    |            |       |  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:       313946 ave      313946 max      313946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313946
Ave neighs/atom = 78.4865
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 = 272.749905730414, Press = -3.8848173057603
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  -17517.928     -17517.928     -17657.306     -17657.306      269.63557      269.63557      44043.954      44043.954     -148.55873     -148.55873    
     25000  -17512.881     -17512.881     -17657.179     -17657.179      279.15498      279.15498      44017.119      44017.119      1146.5275      1146.5275    
Loop time of 329.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.489 hours/ns, 3.036 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    | 328.45     | 328.45     | 328.45     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.04
Output  | 0.00019503 | 0.00019503 | 0.00019503 |   0.0 |  0.00
Modify  | 0.6704     | 0.6704     | 0.6704     |   0.0 |  0.20
Other   |            | 0.0933     |            |       |  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:       314024 ave      314024 max      314024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314024
Ave neighs/atom = 78.506
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 = 272.740845624861, Press = 0.139584068185328
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  -17512.881     -17512.881     -17657.179     -17657.179      279.15498      279.15498      44017.119      44017.119      1146.5275      1146.5275    
     26000  -17517.031     -17517.031     -17658.561     -17658.561      273.7992       273.7992       44058.82       44058.82      -806.37623     -806.37623    
Loop time of 330.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.847 hours/ns, 3.024 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    | 329.74     | 329.74     | 329.74     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14556    | 0.14556    | 0.14556    |   0.0 |  0.04
Output  | 0.00019555 | 0.00019555 | 0.00019555 |   0.0 |  0.00
Modify  | 0.67254    | 0.67254    | 0.67254    |   0.0 |  0.20
Other   |            | 0.09297    |            |       |  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:       314044 ave      314044 max      314044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314044
Ave neighs/atom = 78.511
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 = 272.763715731458, Press = -0.86485837833988
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  -17517.031     -17517.031     -17658.561     -17658.561      273.7992       273.7992       44058.82       44058.82      -806.37623     -806.37623    
     27000  -17516.308     -17516.308     -17655.811     -17655.811      269.87847      269.87847      44022.181      44022.181      931.77427      931.77427    
Loop time of 330.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.758 hours/ns, 3.027 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    | 329.42     | 329.42     | 329.42     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1444     | 0.1444     | 0.1444     |   0.0 |  0.04
Output  | 0.0001937  | 0.0001937  | 0.0001937  |   0.0 |  0.00
Modify  | 0.67235    | 0.67235    | 0.67235    |   0.0 |  0.20
Other   |            | 0.09315    |            |       |  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:       313946 ave      313946 max      313946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313946
Ave neighs/atom = 78.4865
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 = 272.8154118278, Press = -1.13289807558693
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   
     27000  -17516.308     -17516.308     -17655.811     -17655.811      269.87847      269.87847      44022.181      44022.181      931.77427      931.77427    
     28000  -17513.299     -17513.299     -17656.263     -17656.263      276.5737       276.5737       44058.722      44058.722     -538.82354     -538.82354    
Loop time of 330.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.687 hours/ns, 3.030 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    | 329.16     | 329.16     | 329.16     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14588    | 0.14588    | 0.14588    |   0.0 |  0.04
Output  | 0.00019159 | 0.00019159 | 0.00019159 |   0.0 |  0.00
Modify  | 0.67324    | 0.67324    | 0.67324    |   0.0 |  0.20
Other   |            | 0.09309    |            |       |  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:       314094 ave      314094 max      314094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314094
Ave neighs/atom = 78.5235
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 = 272.834753893505, Press = 0.453775707180791
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   
     28000  -17513.299     -17513.299     -17656.263     -17656.263      276.5737       276.5737       44058.722      44058.722     -538.82354     -538.82354    
     29000  -17518.131     -17518.131     -17659.213     -17659.213      272.9318       272.9318       44065.229      44065.229     -1120.3294     -1120.3294    
Loop time of 330.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.823 hours/ns, 3.025 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    | 329.65     | 329.65     | 329.65     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1453     | 0.1453     | 0.1453     |   0.0 |  0.04
Output  | 0.00019172 | 0.00019172 | 0.00019172 |   0.0 |  0.00
Modify  | 0.6729     | 0.6729     | 0.6729     |   0.0 |  0.20
Other   |            | 0.0934     |            |       |  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:       314034 ave      314034 max      314034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314034
Ave neighs/atom = 78.5085
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 = 272.843866321231, Press = -2.18394281076473
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   
     29000  -17518.131     -17518.131     -17659.213     -17659.213      272.9318       272.9318       44065.229      44065.229     -1120.3294     -1120.3294    
     30000  -17516.573     -17516.573     -17656.562     -17656.562      270.81908      270.81908      44005.014      44005.014      1539.8765      1539.8765    
Loop time of 373.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.862 hours/ns, 2.674 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    | 372.85     | 372.85     | 372.85     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15864    | 0.15864    | 0.15864    |   0.0 |  0.04
Output  | 0.00019203 | 0.00019203 | 0.00019203 |   0.0 |  0.00
Modify  | 0.79412    | 0.79412    | 0.79412    |   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:       314002 ave      314002 max      314002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314002
Ave neighs/atom = 78.5005
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 = 272.858144066893, Press = -0.681168397662663
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   
     30000  -17516.573     -17516.573     -17656.562     -17656.562      270.81908      270.81908      44005.014      44005.014      1539.8765      1539.8765    
     31000  -17516.504     -17516.504     -17660.624     -17660.624      278.80915      278.80915      44069.881      44069.881     -1431.8796     -1431.8796    
Loop time of 342.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.256 hours/ns, 2.916 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    | 341.96     | 341.96     | 341.96     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1494     | 0.1494     | 0.1494     |   0.0 |  0.04
Output  | 0.0002432  | 0.0002432  | 0.0002432  |   0.0 |  0.00
Modify  | 0.71437    | 0.71437    | 0.71437    |   0.0 |  0.21
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:       314112 ave      314112 max      314112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314112
Ave neighs/atom = 78.528
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 = 272.834316768555, Press = 0.138141822438646
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   
     31000  -17516.504     -17516.504     -17660.624     -17660.624      278.80915      278.80915      44069.881      44069.881     -1431.8796     -1431.8796    
     32000  -17516.35      -17516.35      -17657.887     -17657.887      273.81222      273.81222      44037.361      44037.361      137.42487      137.42487    
Loop time of 331.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.958 hours/ns, 3.021 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.13     | 330.13     | 330.13     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14612    | 0.14612    | 0.14612    |   0.0 |  0.04
Output  | 0.00023939 | 0.00023939 | 0.00023939 |   0.0 |  0.00
Modify  | 0.67445    | 0.67445    | 0.67445    |   0.0 |  0.20
Other   |            | 0.09265    |            |       |  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:       313948 ave      313948 max      313948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313948
Ave neighs/atom = 78.487
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 = 272.86697959956, Press = -2.34684190855991
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   
     32000  -17516.35      -17516.35      -17657.887     -17657.887      273.81222      273.81222      44037.361      44037.361      137.42487      137.42487    
     33000  -17509.069     -17509.069     -17652.366     -17652.366      277.2168       277.2168       44023.185      44023.185      1309.0204      1309.0204    
Loop time of 330.876 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.910 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    | 329.96     | 329.96     | 329.96     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14666    | 0.14666    | 0.14666    |   0.0 |  0.04
Output  | 0.00019267 | 0.00019267 | 0.00019267 |   0.0 |  0.00
Modify  | 0.67303    | 0.67303    | 0.67303    |   0.0 |  0.20
Other   |            | 0.09318    |            |       |  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:       313970 ave      313970 max      313970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313970
Ave neighs/atom = 78.4925
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 = 272.914244517901, Press = 0.636997534332778
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   
     33000  -17509.069     -17509.069     -17652.366     -17652.366      277.2168       277.2168       44023.185      44023.185      1309.0204      1309.0204    
     34000  -17517.781     -17517.781     -17660.092     -17660.092      275.31004      275.31004      44081.428      44081.428     -1857.545      -1857.545     
Loop time of 331.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.039 hours/ns, 3.018 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.43     | 330.43     | 330.43     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14577    | 0.14577    | 0.14577    |   0.0 |  0.04
Output  | 0.00021402 | 0.00021402 | 0.00021402 |   0.0 |  0.00
Modify  | 0.67426    | 0.67426    | 0.67426    |   0.0 |  0.20
Other   |            | 0.0925     |            |       |  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:       314192 ave      314192 max      314192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314192
Ave neighs/atom = 78.548
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 = 272.938624819873, Press = -0.814504916157759
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   
     34000  -17517.781     -17517.781     -17660.092     -17660.092      275.31004      275.31004      44081.428      44081.428     -1857.545      -1857.545     
     35000  -17519.803     -17519.803     -17656.532     -17656.532      264.51017      264.51017      44015.576      44015.576      1015.8008      1015.8008    
Loop time of 345.278 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 95.911 hours/ns, 2.896 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 344.31     | 344.31     | 344.31     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14962    | 0.14962    | 0.14962    |   0.0 |  0.04
Output  | 0.00024125 | 0.00024125 | 0.00024125 |   0.0 |  0.00
Modify  | 0.71906    | 0.71906    | 0.71906    |   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:       313874 ave      313874 max      313874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313874
Ave neighs/atom = 78.4685
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 = 272.939309931089, Press = -1.49082714429488
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   
     35000  -17519.803     -17519.803     -17656.532     -17656.532      264.51017      264.51017      44015.576      44015.576      1015.8008      1015.8008    
     36000  -17513.675     -17513.675     -17655.63      -17655.63       274.621        274.621        44049.627      44049.627     -101.31643     -101.31643    
Loop time of 328.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.293 hours/ns, 3.043 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    | 327.75     | 327.75     | 327.75     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14163    | 0.14163    | 0.14163    |   0.0 |  0.04
Output  | 0.0001923  | 0.0001923  | 0.0001923  |   0.0 |  0.00
Modify  | 0.672      | 0.672      | 0.672      |   0.0 |  0.20
Other   |            | 0.09436    |            |       |  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:       314180 ave      314180 max      314180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314180
Ave neighs/atom = 78.545
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 = 272.917901572036, Press = 0.758016293590119
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   
     36000  -17513.675     -17513.675     -17655.63      -17655.63       274.621        274.621        44049.627      44049.627     -101.31643     -101.31643    
     37000  -17520.731     -17520.731     -17660.456     -17660.456      270.30693      270.30693      44088.334      44088.334     -2253.449      -2253.449     
Loop time of 349.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.247 ns/day, 97.169 hours/ns, 2.859 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 348.83     | 348.83     | 348.83     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15041    | 0.15041    | 0.15041    |   0.0 |  0.04
Output  | 0.00019271 | 0.00019271 | 0.00019271 |   0.0 |  0.00
Modify  | 0.72816    | 0.72816    | 0.72816    |   0.0 |  0.21
Other   |            | 0.0994     |            |       |  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:       314002 ave      314002 max      314002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314002
Ave neighs/atom = 78.5005
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 = 272.894274289109, Press = -2.49275771209103
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   
     37000  -17520.731     -17520.731     -17660.456     -17660.456      270.30693      270.30693      44088.334      44088.334     -2253.449      -2253.449     
     38000  -17515.838     -17515.838     -17655.638     -17655.638      270.45327      270.45327      43989.517      43989.517      2271.0072      2271.0072    
Loop time of 384.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.811 hours/ns, 2.601 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    | 383.42     | 383.42     | 383.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16343    | 0.16343    | 0.16343    |   0.0 |  0.04
Output  | 0.00024665 | 0.00024665 | 0.00024665 |   0.0 |  0.00
Modify  | 0.83141    | 0.83141    | 0.83141    |   0.0 |  0.22
Other   |            | 0.1056     |            |       |  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:       313822 ave      313822 max      313822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313822
Ave neighs/atom = 78.4555
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 = 272.871921923446, Press = -0.51597750539202
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   
     38000  -17515.838     -17515.838     -17655.638     -17655.638      270.45327      270.45327      43989.517      43989.517      2271.0072      2271.0072    
     39000  -17514.6       -17514.6       -17655.105     -17655.105      271.81709      271.81709      44059.46       44059.46      -549.26377     -549.26377    
Loop time of 335.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.074 hours/ns, 2.984 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    | 334.14     | 334.14     | 334.14     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14914    | 0.14914    | 0.14914    |   0.0 |  0.04
Output  | 0.00024328 | 0.00024328 | 0.00024328 |   0.0 |  0.00
Modify  | 0.68512    | 0.68512    | 0.68512    |   0.0 |  0.20
Other   |            | 0.09413    |            |       |  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:       314234 ave      314234 max      314234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314234
Ave neighs/atom = 78.5585
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 = 272.844067504129, Press = 0.0840124306694866
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   
     39000  -17514.6       -17514.6       -17655.105     -17655.105      271.81709      271.81709      44059.46       44059.46      -549.26377     -549.26377    
     40000  -17516.523     -17516.523     -17655.781     -17655.781      269.40525      269.40525      44047.032      44047.032     -178.67246     -178.67246    
Loop time of 347.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.248 ns/day, 96.608 hours/ns, 2.875 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.82     | 346.82     | 346.82     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1509     | 0.1509     | 0.1509     |   0.0 |  0.04
Output  | 0.00019083 | 0.00019083 | 0.00019083 |   0.0 |  0.00
Modify  | 0.7231     | 0.7231     | 0.7231     |   0.0 |  0.21
Other   |            | 0.09725    |            |       |  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:       314092 ave      314092 max      314092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314092
Ave neighs/atom = 78.523
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 = 272.865804444525, Press = -1.25767377384672
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   
     40000  -17516.523     -17516.523     -17655.781     -17655.781      269.40525      269.40525      44047.032      44047.032     -178.67246     -178.67246    
     41000  -17507.695     -17507.695     -17652.46      -17652.46       280.05763      280.05763      44026.761      44026.761      1033.3491      1033.3491    
Loop time of 329.057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.405 hours/ns, 3.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    | 328.14     | 328.14     | 328.14     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14323    | 0.14323    | 0.14323    |   0.0 |  0.04
Output  | 0.00019293 | 0.00019293 | 0.00019293 |   0.0 |  0.00
Modify  | 0.67471    | 0.67471    | 0.67471    |   0.0 |  0.21
Other   |            | 0.09646    |            |       |  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:       314038 ave      314038 max      314038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314038
Ave neighs/atom = 78.5095
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 = 272.907689714213, Press = -0.146787612382434
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   
     41000  -17507.695     -17507.695     -17652.46      -17652.46       280.05763      280.05763      44026.761      44026.761      1033.3491      1033.3491    
     42000  -17517.437     -17517.437     -17657.901     -17657.901      271.73757      271.73757      44093.959      44093.959     -2301.8217     -2301.8217    
Loop time of 341.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.992 hours/ns, 2.924 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    | 341.01     | 341.01     | 341.01     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14896    | 0.14896    | 0.14896    |   0.0 |  0.04
Output  | 0.00037135 | 0.00037135 | 0.00037135 |   0.0 |  0.00
Modify  | 0.71455    | 0.71455    | 0.71455    |   0.0 |  0.21
Other   |            | 0.0988     |            |       |  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:       314206 ave      314206 max      314206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314206
Ave neighs/atom = 78.5515
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 = 272.949664867331, Press = -0.259622232707518
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   
     42000  -17517.437     -17517.437     -17657.901     -17657.901      271.73757      271.73757      44093.959      44093.959     -2301.8217     -2301.8217    
     43000  -17511.017     -17511.017     -17654.824     -17654.824      278.20396      278.20396      44000.425      44000.425      2013.8607      2013.8607    
Loop time of 353.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.324 hours/ns, 2.825 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    | 352.96     | 352.96     | 352.96     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1543     | 0.1543     | 0.1543     |   0.0 |  0.04
Output  | 0.00018451 | 0.00018451 | 0.00018451 |   0.0 |  0.00
Modify  | 0.74999    | 0.74999    | 0.74999    |   0.0 |  0.21
Other   |            | 0.1002     |            |       |  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:       313866 ave      313866 max      313866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313866
Ave neighs/atom = 78.4665
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 = 272.979933355692, Press = -3.26000965045478
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   
     43000  -17511.017     -17511.017     -17654.824     -17654.824      278.20396      278.20396      44000.425      44000.425      2013.8607      2013.8607    
     44000  -17518.376     -17518.376     -17658.292     -17658.292      270.67761      270.67761      44017.999      44017.999      885.78841      885.78841    
Loop time of 365.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.471 hours/ns, 2.738 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    | 364.24     | 364.24     | 364.24     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16021    | 0.16021    | 0.16021    |   0.0 |  0.04
Output  | 0.00019137 | 0.00019137 | 0.00019137 |   0.0 |  0.00
Modify  | 0.79166    | 0.79166    | 0.79166    |   0.0 |  0.22
Other   |            | 0.1017     |            |       |  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:       314108 ave      314108 max      314108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314108
Ave neighs/atom = 78.527
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 = 273.017979965717, Press = 0.599620436832494
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   
     44000  -17518.376     -17518.376     -17658.292     -17658.292      270.67761      270.67761      44017.999      44017.999      885.78841      885.78841    
     45000  -17512.723     -17512.723     -17654.553     -17654.553      274.38038      274.38038      44072.904      44072.904     -1020.4497     -1020.4497    
Loop time of 346.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.249 ns/day, 96.242 hours/ns, 2.886 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    | 345.49     | 345.49     | 345.49     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15331    | 0.15331    | 0.15331    |   0.0 |  0.04
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.72519    | 0.72519    | 0.72519    |   0.0 |  0.21
Other   |            | 0.09906    |            |       |  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:       314062 ave      314062 max      314062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314062
Ave neighs/atom = 78.5155
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 = 273.034958948793, Press = -0.602386424004379
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   
     45000  -17512.723     -17512.723     -17654.553     -17654.553      274.38038      274.38038      44072.904      44072.904     -1020.4497     -1020.4497    
     46000  -17517.155     -17517.155     -17657.792     -17657.792      272.07172      272.07172      44012.433      44012.433      1136.5823      1136.5823    
Loop time of 342.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.205 hours/ns, 2.918 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    | 341.77     | 341.77     | 341.77     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15063    | 0.15063    | 0.15063    |   0.0 |  0.04
Output  | 0.0002445  | 0.0002445  | 0.0002445  |   0.0 |  0.00
Modify  | 0.72045    | 0.72045    | 0.72045    |   0.0 |  0.21
Other   |            | 0.09791    |            |       |  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:       314026 ave      314026 max      314026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314026
Ave neighs/atom = 78.5065
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 = 273.053771518381, Press = -0.604532568572323
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   
     46000  -17517.155     -17517.155     -17657.792     -17657.792      272.07172      272.07172      44012.433      44012.433      1136.5823      1136.5823    
     47000  -17511.751     -17511.751     -17654.738     -17654.738      276.61726      276.61726      44049.753      44049.753     -111.46613     -111.46613    
Loop time of 389.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.200 hours/ns, 2.567 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    | 388.41     | 388.41     | 388.41     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16507    | 0.16507    | 0.16507    |   0.0 |  0.04
Output  | 0.0002384  | 0.0002384  | 0.0002384  |   0.0 |  0.00
Modify  | 0.8392     | 0.8392     | 0.8392     |   0.0 |  0.22
Other   |            | 0.1065     |            |       |  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:       314044 ave      314044 max      314044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314044
Ave neighs/atom = 78.511
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 = 273.103705296684, Press = 0.541514788917111
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   
     47000  -17511.751     -17511.751     -17654.738     -17654.738      276.61726      276.61726      44049.753      44049.753     -111.46613     -111.46613    
     48000  -17516.194     -17516.194     -17658.13      -17658.13       274.5851       274.5851       44080.165      44080.165     -1656.0831     -1656.0831    
Loop time of 374.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.907 hours/ns, 2.673 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    | 372.99     | 372.99     | 372.99     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16311    | 0.16311    | 0.16311    |   0.0 |  0.04
Output  | 0.00025186 | 0.00025186 | 0.00025186 |   0.0 |  0.00
Modify  | 0.8074     | 0.8074     | 0.8074     |   0.0 |  0.22
Other   |            | 0.1051     |            |       |  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:       314056 ave      314056 max      314056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314056
Ave neighs/atom = 78.514
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 = 273.127370597053, Press = -1.50311664050219
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   
     48000  -17516.194     -17516.194     -17658.13      -17658.13       274.5851       274.5851       44080.165      44080.165     -1656.0831     -1656.0831    
     49000  -17512.529     -17512.529     -17656.434     -17656.434      278.39392      278.39392      43973.555      43973.555      2916.0725      2916.0725    
Loop time of 335.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.174 hours/ns, 2.981 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    | 334.49     | 334.49     | 334.49     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14599    | 0.14599    | 0.14599    |   0.0 |  0.04
Output  | 0.00019372 | 0.00019372 | 0.00019372 |   0.0 |  0.00
Modify  | 0.69629    | 0.69629    | 0.69629    |   0.0 |  0.21
Other   |            | 0.09668    |            |       |  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:       313842 ave      313842 max      313842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313842
Ave neighs/atom = 78.4605
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 = 273.173193354059, Press = -0.314384532104466
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   
     49000  -17512.529     -17512.529     -17656.434     -17656.434      278.39392      278.39392      43973.555      43973.555      2916.0725      2916.0725    
     50000  -17513.694     -17513.694     -17656.412     -17656.412      276.09858      276.09858      44065.435      44065.435     -871.44524     -871.44524    
Loop time of 333.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.701 hours/ns, 2.996 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    | 332.79     | 332.79     | 332.79     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14664    | 0.14664    | 0.14664    |   0.0 |  0.04
Output  | 0.00028305 | 0.00028305 | 0.00028305 |   0.0 |  0.00
Modify  | 0.69091    | 0.69091    | 0.69091    |   0.0 |  0.21
Other   |            | 0.09632    |            |       |  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:       314246 ave      314246 max      314246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314246
Ave neighs/atom = 78.5615
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 = 273.176061775647, Press = 0.242970052643868
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   
     50000  -17513.694     -17513.694     -17656.412     -17656.412      276.09858      276.09858      44065.435      44065.435     -871.44524     -871.44524    
     51000  -17517.165     -17517.165     -17658.455     -17658.455      273.3351       273.3351       44044.295      44044.295     -285.86266     -285.86266    
Loop time of 332.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.303 hours/ns, 3.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    | 331.37     | 331.37     | 331.37     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14485    | 0.14485    | 0.14485    |   0.0 |  0.04
Output  | 0.00019436 | 0.00019436 | 0.00019436 |   0.0 |  0.00
Modify  | 0.68609    | 0.68609    | 0.68609    |   0.0 |  0.21
Other   |            | 0.0955     |            |       |  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:       313914 ave      313914 max      313914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313914
Ave neighs/atom = 78.4785
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 = 273.175703340442, Press = -0.720134133396968
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   
     51000  -17517.165     -17517.165     -17658.455     -17658.455      273.3351       273.3351       44044.295      44044.295     -285.86266     -285.86266    
     52000  -17510.372     -17510.372     -17656.642     -17656.642      282.96937      282.96937      44033.947      44033.947      505.38573      505.38573    
Loop time of 357.493 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.304 hours/ns, 2.797 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.48     | 356.48     | 356.48     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15638    | 0.15638    | 0.15638    |   0.0 |  0.04
Output  | 0.00049627 | 0.00049627 | 0.00049627 |   0.0 |  0.00
Modify  | 0.75931    | 0.75931    | 0.75931    |   0.0 |  0.21
Other   |            | 0.1011     |            |       |  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:       314030 ave      314030 max      314030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314030
Ave neighs/atom = 78.5075
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 = 273.220529567054, Press = -0.248847514884134
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   
     52000  -17510.372     -17510.372     -17656.642     -17656.642      282.96937      282.96937      44033.947      44033.947      505.38573      505.38573    
     53000  -17517.137     -17517.137     -17656.765     -17656.765      270.11939      270.11939      44062.314      44062.314     -835.40279     -835.40279    
Loop time of 337.416 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.727 hours/ns, 2.964 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    | 336.48     | 336.48     | 336.48     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14772    | 0.14772    | 0.14772    |   0.0 |  0.04
Output  | 0.00024707 | 0.00024707 | 0.00024707 |   0.0 |  0.00
Modify  | 0.6904     | 0.6904     | 0.6904     |   0.0 |  0.20
Other   |            | 0.09473    |            |       |  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:       314036 ave      314036 max      314036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314036
Ave neighs/atom = 78.509
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
44042.434065383

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0