# 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 2.863645777106285*${_u_distance}
variable latticeconst_converted equal 2.863645777106285*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86364577710629
Lattice spacing in x,y,z = 2.8636458 2.8636458 2.8636458
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimLee_2006_PtFe__MO_343168101490_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.2330864207 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_343168101490_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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8515.0077     -8515.0077     -8580.4194     -8580.4194      253.15         253.15         23483.233      23483.233      2975.2292      2975.2292    
      1000  -8447.1048     -8447.1048     -8509.9445     -8509.9445      243.19636      243.19636      23735.876      23735.876     -2921.4023     -2921.4023    
Loop time of 53.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.603 ns/day, 14.974 hours/ns, 18.551 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 53.825     | 53.825     | 53.825     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015138   | 0.015138   | 0.015138   |   0.0 |  0.03
Output  | 0.00015906 | 0.00015906 | 0.00015906 |   0.0 |  0.00
Modify  | 0.059797   | 0.059797   | 0.059797   |   0.0 |  0.11
Other   |            | 0.005425   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       176000 ave      176000 max      176000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 176000
Ave neighs/atom = 88
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8447.1048     -8447.1048     -8509.9445     -8509.9445      243.19636      243.19636      23735.876      23735.876     -2921.4023     -2921.4023    
      2000  -8447.1338     -8447.1338     -8511.0683     -8511.0683      247.4333       247.4333       23655.988      23655.988      2625.6953      2625.6953    
Loop time of 59.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.561 hours/ns, 16.773 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.533     | 59.533     | 59.533     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01695    | 0.01695    | 0.01695    |   0.0 |  0.03
Output  | 5.827e-05  | 5.827e-05  | 5.827e-05  |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.10
Other   |            | 0.008835   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191256 ave      191256 max      191256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191256
Ave neighs/atom = 95.628
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8447.1338     -8447.1338     -8511.0683     -8511.0683      247.4333       247.4333       23655.988      23655.988      2625.6953      2625.6953    
      3000  -8448.3831     -8448.3831     -8514.3001     -8514.3001      255.10544      255.10544      23702.663      23702.663     -1090.7314     -1090.7314    
Loop time of 60.1793 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.436 ns/day, 16.716 hours/ns, 16.617 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.081     | 60.081     | 60.081     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019786   | 0.019786   | 0.019786   |   0.0 |  0.03
Output  | 5.3761e-05 | 5.3761e-05 | 5.3761e-05 |   0.0 |  0.00
Modify  | 0.064841   | 0.064841   | 0.064841   |   0.0 |  0.11
Other   |            | 0.01332    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193206 ave      193206 max      193206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193206
Ave neighs/atom = 96.603
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8448.3831     -8448.3831     -8514.3001     -8514.3001      255.10544      255.10544      23702.663      23702.663     -1090.7314     -1090.7314    
      4000  -8445.9179     -8445.9179     -8510.6538     -8510.6538      250.53449      250.53449      23683.897      23683.897      771.78212      771.78212    
Loop time of 60.0704 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.686 hours/ns, 16.647 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.973     | 59.973     | 59.973     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019791   | 0.019791   | 0.019791   |   0.0 |  0.03
Output  | 4.9844e-05 | 4.9844e-05 | 4.9844e-05 |   0.0 |  0.00
Modify  | 0.064742   | 0.064742   | 0.064742   |   0.0 |  0.11
Other   |            | 0.01326    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192290 ave      192290 max      192290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192290
Ave neighs/atom = 96.145
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8445.9179     -8445.9179     -8510.6538     -8510.6538      250.53449      250.53449      23683.897      23683.897      771.78212      771.78212    
      5000  -8449.033      -8449.033      -8513.471      -8513.471       249.38188      249.38188      23686.114      23686.114      78.959784      78.959784    
Loop time of 60.2925 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.433 ns/day, 16.748 hours/ns, 16.586 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.194     | 60.194     | 60.194     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01963    | 0.01963    | 0.01963    |   0.0 |  0.03
Output  | 3.5416e-05 | 3.5416e-05 | 3.5416e-05 |   0.0 |  0.00
Modify  | 0.065015   | 0.065015   | 0.065015   |   0.0 |  0.11
Other   |            | 0.01334    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192662 ave      192662 max      192662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192662
Ave neighs/atom = 96.331
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 = 251.697424398621, Press = -297.284379480409
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8449.033      -8449.033      -8513.471      -8513.471       249.38188      249.38188      23686.114      23686.114      78.959784      78.959784    
      6000  -8446.9742     -8446.9742     -8509.7688     -8509.7688      243.02159      243.02159      23676.154      23676.154      1482.4885      1482.4885    
Loop time of 60.0835 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.690 hours/ns, 16.644 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.982     | 59.982     | 59.982     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019687   | 0.019687   | 0.019687   |   0.0 |  0.03
Output  | 4.6758e-05 | 4.6758e-05 | 4.6758e-05 |   0.0 |  0.00
Modify  | 0.067747   | 0.067747   | 0.067747   |   0.0 |  0.11
Other   |            | 0.01353    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192786 ave      192786 max      192786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192786
Ave neighs/atom = 96.393
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 = 251.627210992668, Press = -2.256927649483
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8446.9742     -8446.9742     -8509.7688     -8509.7688      243.02159      243.02159      23676.154      23676.154      1482.4885      1482.4885    
      7000  -8447.2576     -8447.2576     -8513.7031     -8513.7031      257.15108      257.15108      23717.083      23717.083     -1907.0327     -1907.0327    
Loop time of 60.1165 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.437 ns/day, 16.699 hours/ns, 16.634 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.022     | 60.022     | 60.022     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018159   | 0.018159   | 0.018159   |   0.0 |  0.03
Output  | 3.6188e-05 | 3.6188e-05 | 3.6188e-05 |   0.0 |  0.00
Modify  | 0.065616   | 0.065616   | 0.065616   |   0.0 |  0.11
Other   |            | 0.01085    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192734 ave      192734 max      192734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192734
Ave neighs/atom = 96.367
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 = 252.702031175586, Press = -37.4151955894391
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8447.2576     -8447.2576     -8513.7031     -8513.7031      257.15108      257.15108      23717.083      23717.083     -1907.0327     -1907.0327    
      8000  -8446.7617     -8446.7617     -8513.4689     -8513.4689      258.16359      258.16359      23687.425      23687.425      156.55424      156.55424    
Loop time of 59.8318 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.620 hours/ns, 16.714 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.75      | 59.75      | 59.75      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014866   | 0.014866   | 0.014866   |   0.0 |  0.02
Output  | 3.5888e-05 | 3.5888e-05 | 3.5888e-05 |   0.0 |  0.00
Modify  | 0.061737   | 0.061737   | 0.061737   |   0.0 |  0.10
Other   |            | 0.005257   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191954 ave      191954 max      191954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191954
Ave neighs/atom = 95.977
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 = 252.307726680525, Press = 23.3303235324353
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8446.7617     -8446.7617     -8513.4689     -8513.4689      258.16359      258.16359      23687.425      23687.425      156.55424      156.55424    
      9000  -8445.6065     -8445.6065     -8512.5474     -8512.5474      259.06825      259.06825      23681.249      23681.249      729.19627      729.19627    
Loop time of 59.9514 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.653 hours/ns, 16.680 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.869     | 59.869     | 59.869     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.03
Output  | 3.2592e-05 | 3.2592e-05 | 3.2592e-05 |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.10
Other   |            | 0.005204   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192710 ave      192710 max      192710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192710
Ave neighs/atom = 96.355
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 = 253.076289433258, Press = -16.9012123119771
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8445.6065     -8445.6065     -8512.5474     -8512.5474      259.06825      259.06825      23681.249      23681.249      729.19627      729.19627    
     10000  -8447.7923     -8447.7923     -8510.885      -8510.885       244.17535      244.17535      23711.28       23711.28      -1152.5188     -1152.5188    
Loop time of 60.0594 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.439 ns/day, 16.683 hours/ns, 16.650 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.978     | 59.978     | 59.978     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.02
Output  | 3.2932e-05 | 3.2932e-05 | 3.2932e-05 |   0.0 |  0.00
Modify  | 0.061727   | 0.061727   | 0.061727   |   0.0 |  0.10
Other   |            | 0.005185   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192920 ave      192920 max      192920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192920
Ave neighs/atom = 96.46
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 = 253.177051367974, Press = 3.88428234654348
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8447.7923     -8447.7923     -8510.885      -8510.885       244.17535      244.17535      23711.28       23711.28      -1152.5188     -1152.5188    
     11000  -8450.2659     -8450.2659     -8513.8896     -8513.8896      246.23018      246.23018      23649.238      23649.238      2758.1705      2758.1705    
Loop time of 59.8528 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.626 hours/ns, 16.708 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.771     | 59.771     | 59.771     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014895   | 0.014895   | 0.014895   |   0.0 |  0.02
Output  | 3.3453e-05 | 3.3453e-05 | 3.3453e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.10
Other   |            | 0.00523    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192040 ave      192040 max      192040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192040
Ave neighs/atom = 96.02
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 = 253.158188697234, Press = -1.68727875614904
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8450.2659     -8450.2659     -8513.8896     -8513.8896      246.23018      246.23018      23649.238      23649.238      2758.1705      2758.1705    
     12000  -8445.6999     -8445.6999     -8510.6924     -8510.6924      251.5279       251.5279       23723.534      23723.534     -1925.7107     -1925.7107    
Loop time of 60.0902 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.692 hours/ns, 16.642 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.008     | 60.008     | 60.008     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014892   | 0.014892   | 0.014892   |   0.0 |  0.02
Output  | 3.2752e-05 | 3.2752e-05 | 3.2752e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.10
Other   |            | 0.00528    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193812 ave      193812 max      193812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193812
Ave neighs/atom = 96.906
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 = 252.957802477233, Press = -4.35429290669652
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8445.6999     -8445.6999     -8510.6924     -8510.6924      251.5279       251.5279       23723.534      23723.534     -1925.7107     -1925.7107    
     13000  -8449.3834     -8449.3834     -8514.4668     -8514.4668      251.87938      251.87938      23675.302      23675.302      766.13499      766.13499    
Loop time of 60.0567 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.439 ns/day, 16.682 hours/ns, 16.651 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.975     | 59.975     | 59.975     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.02
Output  | 3.2552e-05 | 3.2552e-05 | 3.2552e-05 |   0.0 |  0.00
Modify  | 0.061683   | 0.061683   | 0.061683   |   0.0 |  0.10
Other   |            | 0.005197   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191778 ave      191778 max      191778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191778
Ave neighs/atom = 95.889
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 = 252.848667194992, Press = 0.549271710921277
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8449.3834     -8449.3834     -8514.4668     -8514.4668      251.87938      251.87938      23675.302      23675.302      766.13499      766.13499    
     14000  -8445.9641     -8445.9641     -8511.2818     -8511.2818      252.78625      252.78625      23700.032      23700.032     -298.2525      -298.2525     
Loop time of 60.1112 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.437 ns/day, 16.698 hours/ns, 16.636 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.029     | 60.029     | 60.029     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.02
Output  | 3.2982e-05 | 3.2982e-05 | 3.2982e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.10
Other   |            | 0.005187   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192972 ave      192972 max      192972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192972
Ave neighs/atom = 96.486
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 = 252.65117645454, Press = -2.40442148970584
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8445.9641     -8445.9641     -8511.2818     -8511.2818      252.78625      252.78625      23700.032      23700.032     -298.2525      -298.2525     
     15000  -8446.1124     -8446.1124     -8511.8993     -8511.8993      254.60235      254.60235      23692.353      23692.353      89.18721       89.18721     
Loop time of 60.0697 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.686 hours/ns, 16.647 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.988     | 59.988     | 59.988     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.02
Output  | 3.3052e-05 | 3.3052e-05 | 3.3052e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.10
Other   |            | 0.005255   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192206 ave      192206 max      192206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192206
Ave neighs/atom = 96.103
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 = 252.557845084313, Press = 0.477325976682687
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8446.1124     -8446.1124     -8511.8993     -8511.8993      254.60235      254.60235      23692.353      23692.353      89.18721       89.18721     
     16000  -8449.6042     -8449.6042     -8513.7295     -8513.7295      248.17157      248.17157      23685.488      23685.488      146.113        146.113      
Loop time of 60.0161 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.671 hours/ns, 16.662 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.934     | 59.934     | 59.934     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014901   | 0.014901   | 0.014901   |   0.0 |  0.02
Output  | 3.2952e-05 | 3.2952e-05 | 3.2952e-05 |   0.0 |  0.00
Modify  | 0.061651   | 0.061651   | 0.061651   |   0.0 |  0.10
Other   |            | 0.005245   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192386 ave      192386 max      192386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192386
Ave neighs/atom = 96.193
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 = 252.424442195283, Press = -4.2411319129128
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8449.6042     -8449.6042     -8513.7295     -8513.7295      248.17157      248.17157      23685.488      23685.488      146.113        146.113      
     17000  -8448.3366     -8448.3366     -8513.6285     -8513.6285      252.68633      252.68633      23698.871      23698.871     -793.07409     -793.07409    
Loop time of 60.0004 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.919     | 59.919     | 59.919     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014884   | 0.014884   | 0.014884   |   0.0 |  0.02
Output  | 3.2711e-05 | 3.2711e-05 | 3.2711e-05 |   0.0 |  0.00
Modify  | 0.061719   | 0.061719   | 0.061719   |   0.0 |  0.10
Other   |            | 0.005226   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192814 ave      192814 max      192814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192814
Ave neighs/atom = 96.407
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 = 252.409396000698, Press = 5.12085782636404
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8448.3366     -8448.3366     -8513.6285     -8513.6285      252.68633      252.68633      23698.871      23698.871     -793.07409     -793.07409    
     18000  -8444.9501     -8444.9501     -8512.1825     -8512.1825      260.19626      260.19626      23669.972      23669.972      1673.5037      1673.5037    
Loop time of 59.8694 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.630 hours/ns, 16.703 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.787     | 59.787     | 59.787     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.03
Output  | 3.3012e-05 | 3.3012e-05 | 3.3012e-05 |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.10
Other   |            | 0.005201   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192468 ave      192468 max      192468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192468
Ave neighs/atom = 96.234
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 = 252.509095866737, Press = -5.85954193325794
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8444.9501     -8444.9501     -8512.1825     -8512.1825      260.19626      260.19626      23669.972      23669.972      1673.5037      1673.5037    
     19000  -8447.9527     -8447.9527     -8512.4275     -8512.4275      249.52432      249.52432      23717.729      23717.729     -1862.3764     -1862.3764    
Loop time of 60.1257 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.437 ns/day, 16.702 hours/ns, 16.632 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.043     | 60.043     | 60.043     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015017   | 0.015017   | 0.015017   |   0.0 |  0.02
Output  | 3.2502e-05 | 3.2502e-05 | 3.2502e-05 |   0.0 |  0.00
Modify  | 0.061781   | 0.061781   | 0.061781   |   0.0 |  0.10
Other   |            | 0.00538    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193124 ave      193124 max      193124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193124
Ave neighs/atom = 96.562
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 = 252.632975535373, Press = 0.926623384175396
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8447.9527     -8447.9527     -8512.4275     -8512.4275      249.52432      249.52432      23717.729      23717.729     -1862.3764     -1862.3764    
     20000  -8446.492      -8446.492      -8513.3194     -8513.3194      258.62915      258.62915      23657.157      23657.157      2366.3238      2366.3238    
Loop time of 59.8939 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.637 hours/ns, 16.696 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.812     | 59.812     | 59.812     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.02
Output  | 3.2751e-05 | 3.2751e-05 | 3.2751e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.10
Other   |            | 0.005319   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192044 ave      192044 max      192044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192044
Ave neighs/atom = 96.022
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 = 252.846373984654, Press = -1.06954493972416
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8446.492      -8446.492      -8513.3194     -8513.3194      258.62915      258.62915      23657.157      23657.157      2366.3238      2366.3238    
     21000  -8446.8278     -8446.8278     -8512.6144     -8512.6144      254.60117      254.60117      23711.706      23711.706     -1495.5999     -1495.5999    
Loop time of 60.1577 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.436 ns/day, 16.710 hours/ns, 16.623 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.076     | 60.076     | 60.076     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014863   | 0.014863   | 0.014863   |   0.0 |  0.02
Output  | 3.2972e-05 | 3.2972e-05 | 3.2972e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.10
Other   |            | 0.005221   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193426 ave      193426 max      193426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193426
Ave neighs/atom = 96.713
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 = 252.868258340597, Press = -2.25343651734669
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8446.8278     -8446.8278     -8512.6144     -8512.6144      254.60117      254.60117      23711.706      23711.706     -1495.5999     -1495.5999    
     22000  -8445.8814     -8445.8814     -8510.3326     -8510.3326      249.4328       249.4328       23690.88       23690.88       430.28785      430.28785    
Loop time of 59.8613 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.628 hours/ns, 16.705 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.779     | 59.779     | 59.779     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.02
Output  | 3.2832e-05 | 3.2832e-05 | 3.2832e-05 |   0.0 |  0.00
Modify  | 0.06166    | 0.06166    | 0.06166    |   0.0 |  0.10
Other   |            | 0.005205   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192242 ave      192242 max      192242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192242
Ave neighs/atom = 96.121
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 = 252.912632394284, Press = -0.160913965752219
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8445.8814     -8445.8814     -8510.3326     -8510.3326      249.4328       249.4328       23690.88       23690.88       430.28785      430.28785    
     23000  -8446.8754     -8446.8754     -8511.42       -8511.42        249.79434      249.79434      23694.208      23694.208     -13.477185     -13.477185    
Loop time of 60.0114 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.670 hours/ns, 16.663 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.93      | 59.93      | 59.93      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.02
Output  | 3.3333e-05 | 3.3333e-05 | 3.3333e-05 |   0.0 |  0.00
Modify  | 0.0616     | 0.0616     | 0.0616     |   0.0 |  0.10
Other   |            | 0.005183   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192444 ave      192444 max      192444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192444
Ave neighs/atom = 96.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.851937472702, Press = -1.16543213014998
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8446.8754     -8446.8754     -8511.42       -8511.42        249.79434      249.79434      23694.208      23694.208     -13.477185     -13.477185    
     24000  -8446.5145     -8446.5145     -8512.355      -8512.355       254.80948      254.80948      23696.213      23696.213     -308.20905     -308.20905    
Loop time of 59.9988 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.666 hours/ns, 16.667 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.917     | 59.917     | 59.917     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014917   | 0.014917   | 0.014917   |   0.0 |  0.02
Output  | 3.2521e-05 | 3.2521e-05 | 3.2521e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.005292   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192522 ave      192522 max      192522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192522
Ave neighs/atom = 96.261
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 = 252.797640952298, Press = -0.424580936440058
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8446.5145     -8446.5145     -8512.355      -8512.355       254.80948      254.80948      23696.213      23696.213     -308.20905     -308.20905    
     25000  -8448.5721     -8448.5721     -8514.1731     -8514.1731      253.88265      253.88265      23687.007      23687.007      6.0505504      6.0505504    
Loop time of 60.0718 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.687 hours/ns, 16.647 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.99      | 59.99      | 59.99      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.02
Output  | 3.4155e-05 | 3.4155e-05 | 3.4155e-05 |   0.0 |  0.00
Modify  | 0.061611   | 0.061611   | 0.061611   |   0.0 |  0.10
Other   |            | 0.005211   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192344 ave      192344 max      192344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192344
Ave neighs/atom = 96.172
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 = 252.721149770896, Press = -1.7036174500528
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8448.5721     -8448.5721     -8514.1731     -8514.1731      253.88265      253.88265      23687.007      23687.007      6.0505504      6.0505504    
     26000  -8448.1668     -8448.1668     -8512.4263     -8512.4263      248.69067      248.69067      23709.839      23709.839     -1306.159      -1306.159     
Loop time of 59.9838 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.662 hours/ns, 16.671 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.902     | 59.902     | 59.902     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014898   | 0.014898   | 0.014898   |   0.0 |  0.02
Output  | 3.3182e-05 | 3.3182e-05 | 3.3182e-05 |   0.0 |  0.00
Modify  | 0.061661   | 0.061661   | 0.061661   |   0.0 |  0.10
Other   |            | 0.005173   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192792 ave      192792 max      192792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192792
Ave neighs/atom = 96.396
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 = 252.712941086221, Press = -0.294065234123262
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8448.1668     -8448.1668     -8512.4263     -8512.4263      248.69067      248.69067      23709.839      23709.839     -1306.159      -1306.159     
     27000  -8446.4697     -8446.4697     -8511.102      -8511.102       250.13361      250.13361      23656.886      23656.886      2817.9878      2817.9878    
Loop time of 59.9233 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.645 hours/ns, 16.688 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.842     | 59.842     | 59.842     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014856   | 0.014856   | 0.014856   |   0.0 |  0.02
Output  | 3.3713e-05 | 3.3713e-05 | 3.3713e-05 |   0.0 |  0.00
Modify  | 0.061648   | 0.061648   | 0.061648   |   0.0 |  0.10
Other   |            | 0.005177   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191982 ave      191982 max      191982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191982
Ave neighs/atom = 95.991
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 = 252.61850650458, Press = -1.40347736855544
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8446.4697     -8446.4697     -8511.102      -8511.102       250.13361      250.13361      23656.886      23656.886      2817.9878      2817.9878    
     28000  -8449.4833     -8449.4833     -8513.4375     -8513.4375      247.50949      247.50949      23719.126      23719.126     -2067.3291     -2067.3291    
Loop time of 60.1036 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.695 hours/ns, 16.638 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.022     | 60.022     | 60.022     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01492    | 0.01492    | 0.01492    |   0.0 |  0.02
Output  | 3.3223e-05 | 3.3223e-05 | 3.3223e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.10
Other   |            | 0.005198   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193282 ave      193282 max      193282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193282
Ave neighs/atom = 96.641
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 = 252.587550458652, Press = -1.42731629917411
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8449.4833     -8449.4833     -8513.4375     -8513.4375      247.50949      247.50949      23719.126      23719.126     -2067.3291     -2067.3291    
     29000  -8445.8563     -8445.8563     -8511.9416     -8511.9416      255.75673      255.75673      23672.086      23672.086      1543.4758      1543.4758    
Loop time of 59.9448 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.651 hours/ns, 16.682 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.863     | 59.863     | 59.863     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015005   | 0.015005   | 0.015005   |   0.0 |  0.03
Output  | 3.2722e-05 | 3.2722e-05 | 3.2722e-05 |   0.0 |  0.00
Modify  | 0.061634   | 0.061634   | 0.061634   |   0.0 |  0.10
Other   |            | 0.005168   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191972 ave      191972 max      191972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191972
Ave neighs/atom = 95.986
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 = 252.581984847534, Press = 0.651562802304806
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8445.8563     -8445.8563     -8511.9416     -8511.9416      255.75673      255.75673      23672.086      23672.086      1543.4758      1543.4758    
     30000  -8448.7761     -8448.7761     -8514.0533     -8514.0533      252.62941      252.62941      23703.762      23703.762     -1089.815      -1089.815     
Loop time of 60.1025 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.695 hours/ns, 16.638 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.021     | 60.021     | 60.021     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.02
Output  | 3.2842e-05 | 3.2842e-05 | 3.2842e-05 |   0.0 |  0.00
Modify  | 0.061599   | 0.061599   | 0.061599   |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193032 ave      193032 max      193032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193032
Ave neighs/atom = 96.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 = 252.593027212073, Press = -2.90539944991372
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8448.7761     -8448.7761     -8514.0533     -8514.0533      252.62941      252.62941      23703.762      23703.762     -1089.815      -1089.815     
     31000  -8447.3561     -8447.3561     -8511.5927     -8511.5927      248.60263      248.60263      23693.346      23693.346      48.204441      48.204441    
Loop time of 59.8623 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.628 hours/ns, 16.705 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.78      | 59.78      | 59.78      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014932   | 0.014932   | 0.014932   |   0.0 |  0.02
Output  | 3.2912e-05 | 3.2912e-05 | 3.2912e-05 |   0.0 |  0.00
Modify  | 0.061651   | 0.061651   | 0.061651   |   0.0 |  0.10
Other   |            | 0.0052     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192432 ave      192432 max      192432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192432
Ave neighs/atom = 96.216
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 = 252.615485509342, Press = 1.88398314108252
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8447.3561     -8447.3561     -8511.5927     -8511.5927      248.60263      248.60263      23693.346      23693.346      48.204441      48.204441    
     32000  -8449.3439     -8449.3439     -8513.4963     -8513.4963      248.2763       248.2763       23669.819      23669.819      1424.2592      1424.2592    
Loop time of 59.9874 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.663 hours/ns, 16.670 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.906     | 59.906     | 59.906     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01491    | 0.01491    | 0.01491    |   0.0 |  0.02
Output  | 3.2712e-05 | 3.2712e-05 | 3.2712e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.10
Other   |            | 0.005174   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192466 ave      192466 max      192466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192466
Ave neighs/atom = 96.233
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 = 252.629254393104, Press = -2.0545021829502
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8449.3439     -8449.3439     -8513.4963     -8513.4963      248.2763       248.2763       23669.819      23669.819      1424.2592      1424.2592    
     33000  -8448.9351     -8448.9351     -8513.8545     -8513.8545      251.24466      251.24466      23712.926      23712.926     -1708.7063     -1708.7063    
Loop time of 59.9677 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.658 hours/ns, 16.676 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.886     | 59.886     | 59.886     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.02
Output  | 3.3182e-05 | 3.3182e-05 | 3.3182e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.10
Other   |            | 0.005196   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193092 ave      193092 max      193092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193092
Ave neighs/atom = 96.546
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 = 252.629438688743, Press = -0.18756780299794
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8448.9351     -8448.9351     -8513.8545     -8513.8545      251.24466      251.24466      23712.926      23712.926     -1708.7063     -1708.7063    
     34000  -8447.0261     -8447.0261     -8514.3077     -8514.3077      260.38691      260.38691      23676.823      23676.823      858.90154      858.90154    
Loop time of 59.9596 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.655 hours/ns, 16.678 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.878     | 59.878     | 59.878     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.02
Output  | 3.2171e-05 | 3.2171e-05 | 3.2171e-05 |   0.0 |  0.00
Modify  | 0.061576   | 0.061576   | 0.061576   |   0.0 |  0.10
Other   |            | 0.005172   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191908 ave      191908 max      191908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191908
Ave neighs/atom = 95.954
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 = 252.562901101626, Press = -0.666111262263668
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8447.0261     -8447.0261     -8514.3077     -8514.3077      260.38691      260.38691      23676.823      23676.823      858.90154      858.90154    
     35000  -8449.8654     -8449.8654     -8515.3059     -8515.3059      253.26152      253.26152      23695.003      23695.003     -711.52086     -711.52086    
Loop time of 60.0128 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.670 hours/ns, 16.663 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.931     | 59.931     | 59.931     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.02
Output  | 3.3143e-05 | 3.3143e-05 | 3.3143e-05 |   0.0 |  0.00
Modify  | 0.06163    | 0.06163    | 0.06163    |   0.0 |  0.10
Other   |            | 0.005168   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192944 ave      192944 max      192944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192944
Ave neighs/atom = 96.472
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 = 252.543440514473, Press = -0.829184150808906
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8449.8654     -8449.8654     -8515.3059     -8515.3059      253.26152      253.26152      23695.003      23695.003     -711.52086     -711.52086    
     36000  -8446.611      -8446.611      -8512.4118     -8512.4118      254.65575      254.65575      23691.634      23691.634     -9.3675918     -9.3675918    
Loop time of 59.9802 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.661 hours/ns, 16.672 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.898     | 59.898     | 59.898     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014888   | 0.014888   | 0.014888   |   0.0 |  0.02
Output  | 2.1871e-05 | 2.1871e-05 | 2.1871e-05 |   0.0 |  0.00
Modify  | 0.0616     | 0.0616     | 0.0616     |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192542 ave      192542 max      192542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192542
Ave neighs/atom = 96.271
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 = 252.558196022555, Press = -0.568375021363216
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8446.611      -8446.611      -8512.4118     -8512.4118      254.65575      254.65575      23691.634      23691.634     -9.3675918     -9.3675918    
     37000  -8444.5871     -8444.5871     -8512.6848     -8512.6848      263.54518      263.54518      23704.35       23704.35      -730.11334     -730.11334    
Loop time of 59.9046 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.640 hours/ns, 16.693 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.823     | 59.823     | 59.823     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014868   | 0.014868   | 0.014868   |   0.0 |  0.02
Output  | 3.191e-05  | 3.191e-05  | 3.191e-05  |   0.0 |  0.00
Modify  | 0.061574   | 0.061574   | 0.061574   |   0.0 |  0.10
Other   |            | 0.005189   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192530 ave      192530 max      192530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192530
Ave neighs/atom = 96.265
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 = 252.592837170663, Press = -1.05966807756144
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8444.5871     -8444.5871     -8512.6848     -8512.6848      263.54518      263.54518      23704.35       23704.35      -730.11334     -730.11334    
     38000  -8447.2688     -8447.2688     -8512.2919     -8512.2919      251.64624      251.64624      23686.879      23686.879      405.84843      405.84843    
Loop time of 59.8757 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.632 hours/ns, 16.701 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.794     | 59.794     | 59.794     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.02
Output  | 3.2752e-05 | 3.2752e-05 | 3.2752e-05 |   0.0 |  0.00
Modify  | 0.061605   | 0.061605   | 0.061605   |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192256 ave      192256 max      192256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192256
Ave neighs/atom = 96.128
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 = 252.672558983041, Press = -0.640070510942745
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8447.2688     -8447.2688     -8512.2919     -8512.2919      251.64624      251.64624      23686.879      23686.879      405.84843      405.84843    
     39000  -8449.4024     -8449.4024     -8514.7269     -8514.7269      252.81267      252.81267      23692.664      23692.664     -524.90369     -524.90369    
Loop time of 59.9667 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.657 hours/ns, 16.676 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.885     | 59.885     | 59.885     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.02
Output  | 3.2141e-05 | 3.2141e-05 | 3.2141e-05 |   0.0 |  0.00
Modify  | 0.06165    | 0.06165    | 0.06165    |   0.0 |  0.10
Other   |            | 0.005188   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192636 ave      192636 max      192636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192636
Ave neighs/atom = 96.318
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 = 252.641905826862, Press = -1.26415044823125
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8449.4024     -8449.4024     -8514.7269     -8514.7269      252.81267      252.81267      23692.664      23692.664     -524.90369     -524.90369    
     40000  -8446.05       -8446.05       -8512.0858     -8512.0858      255.56508      255.56508      23712.725      23712.725     -1253.3894     -1253.3894    
Loop time of 59.9975 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.666 hours/ns, 16.667 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.916     | 59.916     | 59.916     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014889   | 0.014889   | 0.014889   |   0.0 |  0.02
Output  | 3.3664e-05 | 3.3664e-05 | 3.3664e-05 |   0.0 |  0.00
Modify  | 0.061576   | 0.061576   | 0.061576   |   0.0 |  0.10
Other   |            | 0.005173   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192794 ave      192794 max      192794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192794
Ave neighs/atom = 96.397
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 = 252.627641745071, Press = 0.747393690657055
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8446.05       -8446.05       -8512.0858     -8512.0858      255.56508      255.56508      23712.725      23712.725     -1253.3894     -1253.3894    
     41000  -8449.7243     -8449.7243     -8514.7707     -8514.7707      251.73611      251.73611      23643.478      23643.478      3038.2657      3038.2657    
Loop time of 59.9325 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.648 hours/ns, 16.685 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.851     | 59.851     | 59.851     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.02
Output  | 3.3022e-05 | 3.3022e-05 | 3.3022e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.10
Other   |            | 0.005224   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192136 ave      192136 max      192136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192136
Ave neighs/atom = 96.068
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 = 252.601101498358, Press = -1.96434082865625
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8449.7243     -8449.7243     -8514.7707     -8514.7707      251.73611      251.73611      23643.478      23643.478      3038.2657      3038.2657    
     42000  -8445.418      -8445.418      -8511.091      -8511.091       254.16144      254.16144      23725.682      23725.682     -2137.9428     -2137.9428    
Loop time of 60.2259 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.435 ns/day, 16.729 hours/ns, 16.604 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.144     | 60.144     | 60.144     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.02
Output  | 3.2431e-05 | 3.2431e-05 | 3.2431e-05 |   0.0 |  0.00
Modify  | 0.061631   | 0.061631   | 0.061631   |   0.0 |  0.10
Other   |            | 0.005179   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193928 ave      193928 max      193928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193928
Ave neighs/atom = 96.964
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 = 252.621628345461, Press = -0.242926658881718
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8445.418      -8445.418      -8511.091      -8511.091       254.16144      254.16144      23725.682      23725.682     -2137.9428     -2137.9428    
     43000  -8448.0173     -8448.0173     -8513.3339     -8513.3339      252.782        252.782        23670.065      23670.065      1398.6919      1398.6919    
Loop time of 59.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.649 hours/ns, 16.685 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.853     | 59.853     | 59.853     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014844   | 0.014844   | 0.014844   |   0.0 |  0.02
Output  | 3.2602e-05 | 3.2602e-05 | 3.2602e-05 |   0.0 |  0.00
Modify  | 0.06162    | 0.06162    | 0.06162    |   0.0 |  0.10
Other   |            | 0.00517    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191820 ave      191820 max      191820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191820
Ave neighs/atom = 95.91
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 = 252.648186730152, Press = -0.358426110514327
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8448.0173     -8448.0173     -8513.3339     -8513.3339      252.782        252.782        23670.065      23670.065      1398.6919      1398.6919    
     44000  -8448.4181     -8448.4181     -8514.879      -8514.879       257.21086      257.21086      23710.953      23710.953     -1769.8172     -1769.8172    
Loop time of 59.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.649 hours/ns, 16.685 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.853     | 59.853     | 59.853     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.02
Output  | 3.3082e-05 | 3.3082e-05 | 3.3082e-05 |   0.0 |  0.00
Modify  | 0.061595   | 0.061595   | 0.061595   |   0.0 |  0.10
Other   |            | 0.005183   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193184 ave      193184 max      193184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193184
Ave neighs/atom = 96.592
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 = 252.642150672096, Press = -1.28545307085162
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8448.4181     -8448.4181     -8514.879      -8514.879       257.21086      257.21086      23710.953      23710.953     -1769.8172     -1769.8172    
     45000  -8449.4779     -8449.4779     -8513.9247     -8513.9247      249.41613      249.41613      23672.882      23672.882      1048.7783      1048.7783    
Loop time of 59.9708 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.659 hours/ns, 16.675 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.889     | 59.889     | 59.889     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014968   | 0.014968   | 0.014968   |   0.0 |  0.02
Output  | 5.3911e-05 | 5.3911e-05 | 5.3911e-05 |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192274 ave      192274 max      192274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192274
Ave neighs/atom = 96.137
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 = 252.670056778204, Press = 0.579235475861044
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8449.4779     -8449.4779     -8513.9247     -8513.9247      249.41613      249.41613      23672.882      23672.882      1048.7783      1048.7783    
     46000  -8447.35       -8447.35       -8513.0109     -8513.0109      254.11459      254.11459      23690.908      23690.908     -75.605882     -75.605882    
Loop time of 59.9221 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.645 hours/ns, 16.688 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.84      | 59.84      | 59.84      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01495    | 0.01495    | 0.01495    |   0.0 |  0.02
Output  | 3.2982e-05 | 3.2982e-05 | 3.2982e-05 |   0.0 |  0.00
Modify  | 0.061566   | 0.061566   | 0.061566   |   0.0 |  0.10
Other   |            | 0.005185   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192904 ave      192904 max      192904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192904
Ave neighs/atom = 96.452
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 = 252.665804043131, Press = -2.0494034265697
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8447.35       -8447.35       -8513.0109     -8513.0109      254.11459      254.11459      23690.908      23690.908     -75.605882     -75.605882    
     47000  -8447.1995     -8447.1995     -8513.3747     -8513.3747      256.1047       256.1047       23706.02       23706.02      -1202.5144     -1202.5144    
Loop time of 59.8212 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.617 hours/ns, 16.716 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.739     | 59.739     | 59.739     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014887   | 0.014887   | 0.014887   |   0.0 |  0.02
Output  | 3.3163e-05 | 3.3163e-05 | 3.3163e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.005224   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192504 ave      192504 max      192504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192504
Ave neighs/atom = 96.252
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 = 252.702479013571, Press = 0.512103828439242
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8447.1995     -8447.1995     -8513.3747     -8513.3747      256.1047       256.1047       23706.02       23706.02      -1202.5144     -1202.5144    
     48000  -8447.693      -8447.693      -8513.1166     -8513.1166      253.19617      253.19617      23660.949      23660.949      2053.2885      2053.2885    
Loop time of 59.8283 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.619 hours/ns, 16.715 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.746     | 59.746     | 59.746     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.03
Output  | 3.4645e-05 | 3.4645e-05 | 3.4645e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.10
Other   |            | 0.005211   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192112 ave      192112 max      192112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192112
Ave neighs/atom = 96.056
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 = 252.742554142485, Press = -1.17500739251885
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8447.693      -8447.693      -8513.1166     -8513.1166      253.19617      253.19617      23660.949      23660.949      2053.2885      2053.2885    
     49000  -8446.2105     -8446.2105     -8511.7507     -8511.7507      253.64737      253.64737      23714.604      23714.604     -1438.4917     -1438.4917    
Loop time of 60.0723 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.687 hours/ns, 16.647 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.99      | 59.99      | 59.99      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.02
Output  | 2.9325e-05 | 2.9325e-05 | 2.9325e-05 |   0.0 |  0.00
Modify  | 0.0616     | 0.0616     | 0.0616     |   0.0 |  0.10
Other   |            | 0.005168   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193454 ave      193454 max      193454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193454
Ave neighs/atom = 96.727
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 = 252.793958496923, Press = -0.57662399264484
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8446.2105     -8446.2105     -8511.7507     -8511.7507      253.64737      253.64737      23714.604      23714.604     -1438.4917     -1438.4917    
     50000  -8448.6962     -8448.6962     -8514.1347     -8514.1347      253.25383      253.25383      23671.254      23671.254      1151.2675      1151.2675    
Loop time of 59.7661 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.602 hours/ns, 16.732 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.684     | 59.684     | 59.684     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014858   | 0.014858   | 0.014858   |   0.0 |  0.02
Output  | 2.9065e-05 | 2.9065e-05 | 2.9065e-05 |   0.0 |  0.00
Modify  | 0.061619   | 0.061619   | 0.061619   |   0.0 |  0.10
Other   |            | 0.005187   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191816 ave      191816 max      191816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191816
Ave neighs/atom = 95.908
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 = 252.787933924394, Press = -0.163594398748032
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8448.6962     -8448.6962     -8514.1347     -8514.1347      253.25383      253.25383      23671.254      23671.254      1151.2675      1151.2675    
     51000  -8449.2417     -8449.2417     -8513.943      -8513.943       250.40095      250.40095      23703.805      23703.805     -1153.9424     -1153.9424    
Loop time of 60.0162 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.671 hours/ns, 16.662 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.934     | 59.934     | 59.934     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.02
Output  | 2.9575e-05 | 2.9575e-05 | 2.9575e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.10
Other   |            | 0.005185   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192834 ave      192834 max      192834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192834
Ave neighs/atom = 96.417
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 = 252.797985053804, Press = -1.57085219763687
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8449.2417     -8449.2417     -8513.943      -8513.943       250.40095      250.40095      23703.805      23703.805     -1153.9424     -1153.9424    
     52000  -8447.3006     -8447.3006     -8512.0864     -8512.0864      250.72778      250.72778      23685.211      23685.211      544.20512      544.20512    
Loop time of 59.9383 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.650 hours/ns, 16.684 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.857     | 59.857     | 59.857     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014867   | 0.014867   | 0.014867   |   0.0 |  0.02
Output  | 2.9656e-05 | 2.9656e-05 | 2.9656e-05 |   0.0 |  0.00
Modify  | 0.061612   | 0.061612   | 0.061612   |   0.0 |  0.10
Other   |            | 0.005192   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192470 ave      192470 max      192470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192470
Ave neighs/atom = 96.235
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 = 252.753038607272, Press = 0.949451201986467
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8447.3006     -8447.3006     -8512.0864     -8512.0864      250.72778      250.72778      23685.211      23685.211      544.20512      544.20512    
     53000  -8448.7516     -8448.7516     -8513.4208     -8513.4208      250.27626      250.27626      23679.702      23679.702      746.70741      746.70741    
Loop time of 59.9021 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.639 hours/ns, 16.694 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.82      | 59.82      | 59.82      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014924   | 0.014924   | 0.014924   |   0.0 |  0.02
Output  | 2.9586e-05 | 2.9586e-05 | 2.9586e-05 |   0.0 |  0.00
Modify  | 0.061626   | 0.061626   | 0.061626   |   0.0 |  0.10
Other   |            | 0.005173   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192846 ave      192846 max      192846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192846
Ave neighs/atom = 96.423
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 = 252.75408009062, Press = -1.96631586955317
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8448.7516     -8448.7516     -8513.4208     -8513.4208      250.27626      250.27626      23679.702      23679.702      746.70741      746.70741    
     54000  -8445.0874     -8445.0874     -8512.0949     -8512.0949      259.32601      259.32601      23715.19       23715.19      -1470.6966     -1470.6966    
Loop time of 59.9499 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.653 hours/ns, 16.681 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.868     | 59.868     | 59.868     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015086   | 0.015086   | 0.015086   |   0.0 |  0.03
Output  | 3.0087e-05 | 3.0087e-05 | 3.0087e-05 |   0.0 |  0.00
Modify  | 0.061638   | 0.061638   | 0.061638   |   0.0 |  0.10
Other   |            | 0.005205   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192834 ave      192834 max      192834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192834
Ave neighs/atom = 96.417
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 = 252.787195106477, Press = 0.472370053483349
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8445.0874     -8445.0874     -8512.0949     -8512.0949      259.32601      259.32601      23715.19       23715.19      -1470.6966     -1470.6966    
     55000  -8447.8442     -8447.8442     -8513.5671     -8513.5671      254.35457      254.35457      23677.05       23677.05       889.73794      889.73794    
Loop time of 59.8928 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.637 hours/ns, 16.696 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.811     | 59.811     | 59.811     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.02
Output  | 2.9806e-05 | 2.9806e-05 | 2.9806e-05 |   0.0 |  0.00
Modify  | 0.06159    | 0.06159    | 0.06159    |   0.0 |  0.10
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191982 ave      191982 max      191982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191982
Ave neighs/atom = 95.991
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 = 252.812195536988, Press = -0.743592906247225
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8447.8442     -8447.8442     -8513.5671     -8513.5671      254.35457      254.35457      23677.05       23677.05       889.73794      889.73794    
     56000  -8445.4747     -8445.4747     -8511.5813     -8511.5813      255.83927      255.83927      23718.034      23718.034     -1639.3357     -1639.3357    
Loop time of 59.9752 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.660 hours/ns, 16.674 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.893     | 59.893     | 59.893     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.02
Output  | 2.9686e-05 | 2.9686e-05 | 2.9686e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.005208   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193000 ave      193000 max      193000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193000
Ave neighs/atom = 96.5
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 = 252.857770244223, Press = -0.763950553488178
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8445.4747     -8445.4747     -8511.5813     -8511.5813      255.83927      255.83927      23718.034      23718.034     -1639.3357     -1639.3357    
     57000  -8448.3833     -8448.3833     -8513.5625     -8513.5625      252.25035      252.25035      23669.107      23669.107      1505.058       1505.058     
Loop time of 59.888 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.636 hours/ns, 16.698 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.806     | 59.806     | 59.806     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014843   | 0.014843   | 0.014843   |   0.0 |  0.02
Output  | 2.9415e-05 | 2.9415e-05 | 2.9415e-05 |   0.0 |  0.00
Modify  | 0.061611   | 0.061611   | 0.061611   |   0.0 |  0.10
Other   |            | 0.005182   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191992 ave      191992 max      191992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191992
Ave neighs/atom = 95.996
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 = 252.874779503745, Press = 0.0616269055044602
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8448.3833     -8448.3833     -8513.5625     -8513.5625      252.25035      252.25035      23669.107      23669.107      1505.058       1505.058     
     58000  -8448.9512     -8448.9512     -8512.7417     -8512.7417      246.87581      246.87581      23718.581      23718.581     -2010.9714     -2010.9714    
Loop time of 59.9414 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.650 hours/ns, 16.683 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.86      | 59.86      | 59.86      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014887   | 0.014887   | 0.014887   |   0.0 |  0.02
Output  | 2.8553e-05 | 2.8553e-05 | 2.8553e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.10
Other   |            | 0.005187   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193158 ave      193158 max      193158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193158
Ave neighs/atom = 96.579
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 = 252.908085332994, Press = -2.18337305785362
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8448.9512     -8448.9512     -8512.7417     -8512.7417      246.87581      246.87581      23718.581      23718.581     -2010.9714     -2010.9714    
     59000  -8448.3964     -8448.3964     -8513.3499     -8513.3499      251.37678      251.37678      23687.884      23687.884      172.48631      172.48631    
Loop time of 59.8201 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.617 hours/ns, 16.717 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.738     | 59.738     | 59.738     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014942   | 0.014942   | 0.014942   |   0.0 |  0.02
Output  | 2.9435e-05 | 2.9435e-05 | 2.9435e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.10
Other   |            | 0.005243   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191672 ave      191672 max      191672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191672
Ave neighs/atom = 95.836
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 = 252.89522902576, Press = 1.43112016439426
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8448.3964     -8448.3964     -8513.3499     -8513.3499      251.37678      251.37678      23687.884      23687.884      172.48631      172.48631    
     60000  -8447.5313     -8447.5313     -8513.3124     -8513.3124      254.57974      254.57974      23682.251      23682.251      633.59801      633.59801    
Loop time of 59.8769 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.632 hours/ns, 16.701 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.795     | 59.795     | 59.795     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014887   | 0.014887   | 0.014887   |   0.0 |  0.02
Output  | 2.9105e-05 | 2.9105e-05 | 2.9105e-05 |   0.0 |  0.00
Modify  | 0.061762   | 0.061762   | 0.061762   |   0.0 |  0.10
Other   |            | 0.005224   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192730 ave      192730 max      192730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192730
Ave neighs/atom = 96.365
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 = 252.90194893245, Press = -1.14857226972871
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8447.5313     -8447.5313     -8513.3124     -8513.3124      254.57974      254.57974      23682.251      23682.251      633.59801      633.59801    
     61000  -8447.911      -8447.911      -8514.4825     -8514.4825      257.63839      257.63839      23702.352      23702.352     -1069.1545     -1069.1545    
Loop time of 60.0921 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.692 hours/ns, 16.641 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.01      | 60.01      | 60.01      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014885   | 0.014885   | 0.014885   |   0.0 |  0.02
Output  | 2.8805e-05 | 2.8805e-05 | 2.8805e-05 |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.10
Other   |            | 0.005235   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192974 ave      192974 max      192974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192974
Ave neighs/atom = 96.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 = 252.865837471759, Press = 0.103280902277257
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8447.911      -8447.911      -8514.4825     -8514.4825      257.63839      257.63839      23702.352      23702.352     -1069.1545     -1069.1545    
     62000  -8448.3841     -8448.3841     -8511.9313     -8511.9313      245.93416      245.93416      23669.374      23669.374      1694.5702      1694.5702    
Loop time of 59.9565 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.655 hours/ns, 16.679 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.875     | 59.875     | 59.875     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014849   | 0.014849   | 0.014849   |   0.0 |  0.02
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.061696   | 0.061696   | 0.061696   |   0.0 |  0.10
Other   |            | 0.005239   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192610 ave      192610 max      192610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192610
Ave neighs/atom = 96.305
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 = 252.877448842005, Press = -0.736855027332732
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8448.3841     -8448.3841     -8511.9313     -8511.9313      245.93416      245.93416      23669.374      23669.374      1694.5702      1694.5702    
     63000  -8449.1249     -8449.1249     -8513.1149     -8513.1149      247.64806      247.64806      23732.651      23732.651     -3068.3225     -3068.3225    
Loop time of 60.0581 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.439 ns/day, 16.683 hours/ns, 16.651 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.976     | 59.976     | 59.976     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.02
Output  | 2.9115e-05 | 2.9115e-05 | 2.9115e-05 |   0.0 |  0.00
Modify  | 0.061696   | 0.061696   | 0.061696   |   0.0 |  0.10
Other   |            | 0.005267   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193132 ave      193132 max      193132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193132
Ave neighs/atom = 96.566
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 = 252.885780663818, Press = -0.302543804720531
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8449.1249     -8449.1249     -8513.1149     -8513.1149      247.64806      247.64806      23732.651      23732.651     -3068.3225     -3068.3225    
     64000  -8444.1494     -8444.1494     -8511.217      -8511.217       259.55854      259.55854      23637.858      23637.858      4221.1794      4221.1794    
Loop time of 59.8279 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.619 hours/ns, 16.715 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.746     | 59.746     | 59.746     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014866   | 0.014866   | 0.014866   |   0.0 |  0.02
Output  | 2.8794e-05 | 2.8794e-05 | 2.8794e-05 |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.10
Other   |            | 0.00524    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191450 ave      191450 max      191450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191450
Ave neighs/atom = 95.725
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 = 252.908712403317, Press = 0.415546439020733
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8444.1494     -8444.1494     -8511.217      -8511.217       259.55854      259.55854      23637.858      23637.858      4221.1794      4221.1794    
     65000  -8448.7181     -8448.7181     -8513.5116     -8513.5116      250.75774      250.75774      23714.539      23714.539     -1845.0342     -1845.0342    
Loop time of 60.1357 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.437 ns/day, 16.704 hours/ns, 16.629 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.054     | 60.054     | 60.054     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014911   | 0.014911   | 0.014911   |   0.0 |  0.02
Output  | 2.8464e-05 | 2.8464e-05 | 2.8464e-05 |   0.0 |  0.00
Modify  | 0.061712   | 0.061712   | 0.061712   |   0.0 |  0.10
Other   |            | 0.00525    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193672 ave      193672 max      193672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193672
Ave neighs/atom = 96.836
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 = 252.92629214844, Press = -0.941808028076645
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8448.7181     -8448.7181     -8513.5116     -8513.5116      250.75774      250.75774      23714.539      23714.539     -1845.0342     -1845.0342    
     66000  -8444.4999     -8444.4999     -8512.2742     -8512.2742      262.29362      262.29362      23685.504      23685.504      644.43832      644.43832    
Loop time of 59.9232 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.645 hours/ns, 16.688 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.841     | 59.841     | 59.841     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.02
Output  | 2.8454e-05 | 2.8454e-05 | 2.8454e-05 |   0.0 |  0.00
Modify  | 0.061782   | 0.061782   | 0.061782   |   0.0 |  0.10
Other   |            | 0.005228   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191892 ave      191892 max      191892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191892
Ave neighs/atom = 95.946
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 = 252.940501281617, Press = 0.495461067422265
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8444.4999     -8444.4999     -8512.2742     -8512.2742      262.29362      262.29362      23685.504      23685.504      644.43832      644.43832    
     67000  -8448.2004     -8448.2004     -8512.7426     -8512.7426      249.785        249.785        23682.279      23682.279      580.10857      580.10857    
Loop time of 59.8927 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.637 hours/ns, 16.697 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.811     | 59.811     | 59.811     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014829   | 0.014829   | 0.014829   |   0.0 |  0.02
Output  | 2.9145e-05 | 2.9145e-05 | 2.9145e-05 |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.10
Other   |            | 0.00524    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192564 ave      192564 max      192564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192564
Ave neighs/atom = 96.282
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 = 252.972791681157, Press = -1.02169977936397
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8448.2004     -8448.2004     -8512.7426     -8512.7426      249.785        249.785        23682.279      23682.279      580.10857      580.10857    
     68000  -8444.965      -8444.965      -8511.0904     -8511.0904      255.91231      255.91231      23717.35       23717.35      -1548.369      -1548.369     
Loop time of 59.968 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.658 hours/ns, 16.676 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.886     | 59.886     | 59.886     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014886   | 0.014886   | 0.014886   |   0.0 |  0.02
Output  | 2.9175e-05 | 2.9175e-05 | 2.9175e-05 |   0.0 |  0.00
Modify  | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.10
Other   |            | 0.00522    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192702 ave      192702 max      192702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192702
Ave neighs/atom = 96.351
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 = 253.003605855521, Press = 0.248806728074361
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8444.965      -8444.965      -8511.0904     -8511.0904      255.91231      255.91231      23717.35       23717.35      -1548.369      -1548.369     
     69000  -8446.3394     -8446.3394     -8513.5712     -8513.5712      260.19403      260.19403      23675.286      23675.286      1027.3135      1027.3135    
Loop time of 59.8058 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.613 hours/ns, 16.721 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.724     | 59.724     | 59.724     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.03
Output  | 2.8534e-05 | 2.8534e-05 | 2.8534e-05 |   0.0 |  0.00
Modify  | 0.061696   | 0.061696   | 0.061696   |   0.0 |  0.10
Other   |            | 0.005224   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191862 ave      191862 max      191862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191862
Ave neighs/atom = 95.931
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 = 252.997402771325, Press = -0.433648213796524
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8446.3394     -8446.3394     -8513.5712     -8513.5712      260.19403      260.19403      23675.286      23675.286      1027.3135      1027.3135    
     70000  -8449.3147     -8449.3147     -8514.7453     -8514.7453      253.22323      253.22323      23703.235      23703.235     -1254.1174     -1254.1174    
Loop time of 59.9988 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.666 hours/ns, 16.667 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.917     | 59.917     | 59.917     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.02
Output  | 2.8464e-05 | 2.8464e-05 | 2.8464e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.10
Other   |            | 0.005248   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192842 ave      192842 max      192842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192842
Ave neighs/atom = 96.421
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 = 252.978945193802, Press = -0.416491728971716
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8449.3147     -8449.3147     -8514.7453     -8514.7453      253.22323      253.22323      23703.235      23703.235     -1254.1174     -1254.1174    
     71000  -8448.261      -8448.261      -8513.0919     -8513.0919      250.90245      250.90245      23679.819      23679.819      708.83702      708.83702    
Loop time of 59.9951 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.665 hours/ns, 16.668 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.913     | 59.913     | 59.913     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014851   | 0.014851   | 0.014851   |   0.0 |  0.02
Output  | 2.9325e-05 | 2.9325e-05 | 2.9325e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.10
Other   |            | 0.005225   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192250 ave      192250 max      192250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192250
Ave neighs/atom = 96.125
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
23691.158209437

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0