# 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.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.502431 28.502431 28.502431)
  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.502431 28.502431 28.502431)
  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_MahataMukhopadhyayAsleZaeem_2022_AlFe__MO_304347095149_001
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 23155.0486762528    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23155.0486762528*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23155.0486762528 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_304347095149_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8515.2661     -8515.2661     -8580.6777     -8580.6777      253.15         253.15         23155.049      23155.049      3017.3681      3017.3681    
      1000  -8448.0954     -8448.0954     -8511.4817     -8511.4817      245.31128      245.31128      23385.632      23385.632     -2768.1037     -2768.1037    
Loop time of 36.7167 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.353 ns/day, 10.199 hours/ns, 27.236 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 36.636     | 36.636     | 36.636     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.04
Output  | 9.7643e-05 | 9.7643e-05 | 9.7643e-05 |   0.0 |  0.00
Modify  | 0.059805   | 0.059805   | 0.059805   |   0.0 |  0.16
Other   |            | 0.005528   |            |       |  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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8448.0954     -8448.0954     -8511.4817     -8511.4817      245.31128      245.31128      23385.632      23385.632     -2768.1037     -2768.1037    
      2000  -8447.2073     -8447.2073     -8511.2036     -8511.2036      247.67221      247.67221      23343.921      23343.921      254.50231      254.50231    
Loop time of 42.2423 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.045 ns/day, 11.734 hours/ns, 23.673 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    | 42.162     | 42.162     | 42.162     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015023   | 0.015023   | 0.015023   |   0.0 |  0.04
Output  | 5.5004e-05 | 5.5004e-05 | 5.5004e-05 |   0.0 |  0.00
Modify  | 0.059591   | 0.059591   | 0.059591   |   0.0 |  0.14
Other   |            | 0.005404   |            |       |  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:       131490 ave      131490 max      131490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131490
Ave neighs/atom = 65.745
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8447.2073     -8447.2073     -8511.2036     -8511.2036      247.67221      247.67221      23343.921      23343.921      254.50231      254.50231    
      3000  -8449.2663     -8449.2663     -8516.7611     -8516.7611      261.21165      261.21165      23340.388      23340.388     -153.87492     -153.87492    
Loop time of 42.6353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.026 ns/day, 11.843 hours/ns, 23.455 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    | 42.555     | 42.555     | 42.555     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015065   | 0.015065   | 0.015065   |   0.0 |  0.04
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.059537   | 0.059537   | 0.059537   |   0.0 |  0.14
Other   |            | 0.005405   |            |       |  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:       131352 ave      131352 max      131352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131352
Ave neighs/atom = 65.676
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8449.2663     -8449.2663     -8516.7611     -8516.7611      261.21165      261.21165      23340.388      23340.388     -153.87492     -153.87492    
      4000  -8446.7489     -8446.7489     -8509.5269     -8509.5269      242.95732      242.95732      23360.774      23360.774     -732.25677     -732.25677    
Loop time of 42.7353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.871 hours/ns, 23.400 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    | 42.655     | 42.655     | 42.655     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.04
Output  | 5.3981e-05 | 5.3981e-05 | 5.3981e-05 |   0.0 |  0.00
Modify  | 0.059646   | 0.059646   | 0.059646   |   0.0 |  0.14
Other   |            | 0.005402   |            |       |  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:       130978 ave      130978 max      130978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130978
Ave neighs/atom = 65.489
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8446.7489     -8446.7489     -8509.5269     -8509.5269      242.95732      242.95732      23360.774      23360.774     -732.25677     -732.25677    
      5000  -8449.1581     -8449.1581     -8515.9525     -8515.9525      258.50139      258.50139      23322.815      23322.815      1229.9011      1229.9011    
Loop time of 42.8868 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.015 ns/day, 11.913 hours/ns, 23.317 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    | 42.806     | 42.806     | 42.806     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015036   | 0.015036   | 0.015036   |   0.0 |  0.04
Output  | 3.9855e-05 | 3.9855e-05 | 3.9855e-05 |   0.0 |  0.00
Modify  | 0.059873   | 0.059873   | 0.059873   |   0.0 |  0.14
Other   |            | 0.005401   |            |       |  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:       131490 ave      131490 max      131490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131490
Ave neighs/atom = 65.745
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 = 250.926647938141, Press = -193.641723234244
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8449.1581     -8449.1581     -8515.9525     -8515.9525      258.50139      258.50139      23322.815      23322.815      1229.9011      1229.9011    
      6000  -8447.2421     -8447.2421     -8513.0631     -8513.0631      254.73398      254.73398      23370.219      23370.219     -1638.0995     -1638.0995    
Loop time of 42.5948 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.832 hours/ns, 23.477 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    | 42.512     | 42.512     | 42.512     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.04
Output  | 3.8372e-05 | 3.8372e-05 | 3.8372e-05 |   0.0 |  0.00
Modify  | 0.06207    | 0.06207    | 0.06207    |   0.0 |  0.15
Other   |            | 0.005432   |            |       |  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:       130998 ave      130998 max      130998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130998
Ave neighs/atom = 65.499
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.650161175628, Press = 12.8024289050525
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8447.2421     -8447.2421     -8513.0631     -8513.0631      254.73398      254.73398      23370.219      23370.219     -1638.0995     -1638.0995    
      7000  -8448.3137     -8448.3137     -8514.9982     -8514.9982      258.07568      258.07568      23333.408      23333.408      613.78421      613.78421    
Loop time of 42.7199 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.867 hours/ns, 23.408 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    | 42.638     | 42.638     | 42.638     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.04
Output  | 2.9125e-05 | 2.9125e-05 | 2.9125e-05 |   0.0 |  0.00
Modify  | 0.061856   | 0.061856   | 0.061856   |   0.0 |  0.14
Other   |            | 0.005406   |            |       |  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:       131228 ave      131228 max      131228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131228
Ave neighs/atom = 65.614
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.020154345995, Press = -52.6067286181535
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8448.3137     -8448.3137     -8514.9982     -8514.9982      258.07568      258.07568      23333.408      23333.408      613.78421      613.78421    
      8000  -8449.3487     -8449.3487     -8512.6115     -8512.6115      244.83357      244.83357      23335.525      23335.525      676.24928      676.24928    
Loop time of 42.724 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.868 hours/ns, 23.406 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    | 42.641     | 42.641     | 42.641     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.04
Output  | 4.0897e-05 | 4.0897e-05 | 4.0897e-05 |   0.0 |  0.00
Modify  | 0.062104   | 0.062104   | 0.062104   |   0.0 |  0.15
Other   |            | 0.005427   |            |       |  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:       131206 ave      131206 max      131206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131206
Ave neighs/atom = 65.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 = 252.09616009283, Press = 13.8839003066029
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8449.3487     -8449.3487     -8512.6115     -8512.6115      244.83357      244.83357      23335.525      23335.525      676.24928      676.24928    
      9000  -8447.0666     -8447.0666     -8512.2432     -8512.2432      252.23994      252.23994      23361.453      23361.453     -1104.6354     -1104.6354    
Loop time of 42.9863 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.010 ns/day, 11.941 hours/ns, 23.263 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    | 42.904     | 42.904     | 42.904     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015023   | 0.015023   | 0.015023   |   0.0 |  0.03
Output  | 4.294e-05  | 4.294e-05  | 4.294e-05  |   0.0 |  0.00
Modify  | 0.0622     | 0.0622     | 0.0622     |   0.0 |  0.14
Other   |            | 0.005443   |            |       |  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:       131276 ave      131276 max      131276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131276
Ave neighs/atom = 65.638
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.700084339898, Press = -12.4170971268492
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8447.0666     -8447.0666     -8512.2432     -8512.2432      252.23994      252.23994      23361.453      23361.453     -1104.6354     -1104.6354    
     10000  -8449.0321     -8449.0321     -8513.1355     -8513.1355      248.08697      248.08697      23319.799      23319.799      1687.8779      1687.8779    
Loop time of 42.814 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.018 ns/day, 11.893 hours/ns, 23.357 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    | 42.731     | 42.731     | 42.731     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015052   | 0.015052   | 0.015052   |   0.0 |  0.04
Output  | 4.1929e-05 | 4.1929e-05 | 4.1929e-05 |   0.0 |  0.00
Modify  | 0.062119   | 0.062119   | 0.062119   |   0.0 |  0.15
Other   |            | 0.005457   |            |       |  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:       131240 ave      131240 max      131240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131240
Ave neighs/atom = 65.62
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.000692588287, Press = 0.725162035924074
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8449.0321     -8449.0321     -8513.1355     -8513.1355      248.08697      248.08697      23319.799      23319.799      1687.8779      1687.8779    
     11000  -8445.6785     -8445.6785     -8511.7565     -8511.7565      255.72862      255.72862      23371.77       23371.77      -1602.5534     -1602.5534    
Loop time of 42.5353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.031 ns/day, 11.815 hours/ns, 23.510 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    | 42.453     | 42.453     | 42.453     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.04
Output  | 3.3042e-05 | 3.3042e-05 | 3.3042e-05 |   0.0 |  0.00
Modify  | 0.061936   | 0.061936   | 0.061936   |   0.0 |  0.15
Other   |            | 0.005413   |            |       |  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:       131404 ave      131404 max      131404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131404
Ave neighs/atom = 65.702
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.590859042296, Press = -3.56590361370047
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8445.6785     -8445.6785     -8511.7565     -8511.7565      255.72862      255.72862      23371.77       23371.77      -1602.5534     -1602.5534    
     12000  -8448.1674     -8448.1674     -8514.7548     -8514.7548      257.7001       257.7001       23324.967      23324.967      1319.8497      1319.8497    
Loop time of 42.6587 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.025 ns/day, 11.850 hours/ns, 23.442 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    | 42.576     | 42.576     | 42.576     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014973   | 0.014973   | 0.014973   |   0.0 |  0.04
Output  | 4.0927e-05 | 4.0927e-05 | 4.0927e-05 |   0.0 |  0.00
Modify  | 0.062032   | 0.062032   | 0.062032   |   0.0 |  0.15
Other   |            | 0.005426   |            |       |  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:       131084 ave      131084 max      131084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131084
Ave neighs/atom = 65.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.77091101086, Press = -4.33392781146505
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8448.1674     -8448.1674     -8514.7548     -8514.7548      257.7001       257.7001       23324.967      23324.967      1319.8497      1319.8497    
     13000  -8444.7768     -8444.7768     -8514.093      -8514.093       268.26097      268.26097      23377.99       23377.99      -2298.6682     -2298.6682    
Loop time of 42.7756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.020 ns/day, 11.882 hours/ns, 23.378 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    | 42.693     | 42.693     | 42.693     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.04
Output  | 3.9074e-05 | 3.9074e-05 | 3.9074e-05 |   0.0 |  0.00
Modify  | 0.06211    | 0.06211    | 0.06211    |   0.0 |  0.15
Other   |            | 0.005452   |            |       |  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:       131394 ave      131394 max      131394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131394
Ave neighs/atom = 65.697
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.108394032774, Press = 0.997116224040912
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8444.7768     -8444.7768     -8514.093      -8514.093       268.26097      268.26097      23377.99       23377.99      -2298.6682     -2298.6682    
     14000  -8447.1761     -8447.1761     -8512.585      -8512.585       253.139        253.139        23329.769      23329.769      1225.972       1225.972     
Loop time of 42.5591 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.030 ns/day, 11.822 hours/ns, 23.497 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    | 42.477     | 42.477     | 42.477     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015048   | 0.015048   | 0.015048   |   0.0 |  0.04
Output  | 2.9716e-05 | 2.9716e-05 | 2.9716e-05 |   0.0 |  0.00
Modify  | 0.061982   | 0.061982   | 0.061982   |   0.0 |  0.15
Other   |            | 0.00543    |            |       |  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:       130978 ave      130978 max      130978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130978
Ave neighs/atom = 65.489
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.066021261573, Press = -6.33835171270598
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8447.1761     -8447.1761     -8512.585      -8512.585       253.139        253.139        23329.769      23329.769      1225.972       1225.972     
     15000  -8451.6904     -8451.6904     -8513.2906     -8513.2906      238.39882      238.39882      23339.911      23339.911      164.74996      164.74996    
Loop time of 42.9299 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.013 ns/day, 11.925 hours/ns, 23.294 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    | 42.847     | 42.847     | 42.847     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.03
Output  | 4.232e-05  | 4.232e-05  | 4.232e-05  |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.14
Other   |            | 0.005409   |            |       |  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:       131432 ave      131432 max      131432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131432
Ave neighs/atom = 65.716
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.982319401304, Press = 4.75352110824671
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8451.6904     -8451.6904     -8513.2906     -8513.2906      238.39882      238.39882      23339.911      23339.911      164.74996      164.74996    
     16000  -8446.1154     -8446.1154     -8512.9668     -8512.9668      258.72161      258.72161      23364.214      23364.214     -1161.4841     -1161.4841    
Loop time of 42.8631 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.906 hours/ns, 23.330 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    | 42.781     | 42.781     | 42.781     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.04
Output  | 4.1498e-05 | 4.1498e-05 | 4.1498e-05 |   0.0 |  0.00
Modify  | 0.061936   | 0.061936   | 0.061936   |   0.0 |  0.14
Other   |            | 0.005446   |            |       |  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:       131164 ave      131164 max      131164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131164
Ave neighs/atom = 65.582
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.821904535481, Press = -3.79461099630382
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8446.1154     -8446.1154     -8512.9668     -8512.9668      258.72161      258.72161      23364.214      23364.214     -1161.4841     -1161.4841    
     17000  -8447.656      -8447.656      -8512.9395     -8512.9395      252.65406      252.65406      23334.494      23334.494      858.76271      858.76271    
Loop time of 42.9916 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.010 ns/day, 11.942 hours/ns, 23.260 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    | 42.909     | 42.909     | 42.909     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015096   | 0.015096   | 0.015096   |   0.0 |  0.04
Output  | 3.8002e-05 | 3.8002e-05 | 3.8002e-05 |   0.0 |  0.00
Modify  | 0.061995   | 0.061995   | 0.061995   |   0.0 |  0.14
Other   |            | 0.005445   |            |       |  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:       131130 ave      131130 max      131130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131130
Ave neighs/atom = 65.565
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.006078685879, Press = -0.402568246679262
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8447.656      -8447.656      -8512.9395     -8512.9395      252.65406      252.65406      23334.494      23334.494      858.76271      858.76271    
     18000  -8449.6819     -8449.6819     -8515.8058     -8515.8058      255.90637      255.90637      23353.654      23353.654     -942.66753     -942.66753    
Loop time of 42.8363 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.899 hours/ns, 23.345 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    | 42.754     | 42.754     | 42.754     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015105   | 0.015105   | 0.015105   |   0.0 |  0.04
Output  | 3.4766e-05 | 3.4766e-05 | 3.4766e-05 |   0.0 |  0.00
Modify  | 0.062057   | 0.062057   | 0.062057   |   0.0 |  0.14
Other   |            | 0.005449   |            |       |  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:       131238 ave      131238 max      131238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131238
Ave neighs/atom = 65.619
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.031409712379, Press = -2.06855609882029
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8449.6819     -8449.6819     -8515.8058     -8515.8058      255.90637      255.90637      23353.654      23353.654     -942.66753     -942.66753    
     19000  -8445.3815     -8445.3815     -8511.9115     -8511.9115      257.4781       257.4781       23324.55       23324.55       1678.7015      1678.7015    
Loop time of 42.6707 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.025 ns/day, 11.853 hours/ns, 23.435 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    | 42.588     | 42.588     | 42.588     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.04
Output  | 4.1367e-05 | 4.1367e-05 | 4.1367e-05 |   0.0 |  0.00
Modify  | 0.062021   | 0.062021   | 0.062021   |   0.0 |  0.15
Other   |            | 0.005467   |            |       |  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:       131006 ave      131006 max      131006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131006
Ave neighs/atom = 65.503
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.094079420037, Press = -1.72364042246425
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8445.3815     -8445.3815     -8511.9115     -8511.9115      257.4781       257.4781       23324.55       23324.55       1678.7015      1678.7015    
     20000  -8446.5726     -8446.5726     -8512.5575     -8512.5575      255.36872      255.36872      23386.688      23386.688     -2789.0888     -2789.0888    
Loop time of 42.9468 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.012 ns/day, 11.930 hours/ns, 23.285 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    | 42.864     | 42.864     | 42.864     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015053   | 0.015053   | 0.015053   |   0.0 |  0.04
Output  | 3.8252e-05 | 3.8252e-05 | 3.8252e-05 |   0.0 |  0.00
Modify  | 0.062079   | 0.062079   | 0.062079   |   0.0 |  0.14
Other   |            | 0.005464   |            |       |  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:       131504 ave      131504 max      131504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131504
Ave neighs/atom = 65.752
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.369361734571, Press = 0.995546065611437
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8446.5726     -8446.5726     -8512.5575     -8512.5575      255.36872      255.36872      23386.688      23386.688     -2789.0888     -2789.0888    
     21000  -8447.668      -8447.668      -8515.1881     -8515.1881      261.31007      261.31007      23321.167      23321.167      1545.2265      1545.2265    
Loop time of 42.8783 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.015 ns/day, 11.911 hours/ns, 23.322 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    | 42.796     | 42.796     | 42.796     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015006   | 0.015006   | 0.015006   |   0.0 |  0.03
Output  | 2.9896e-05 | 2.9896e-05 | 2.9896e-05 |   0.0 |  0.00
Modify  | 0.062029   | 0.062029   | 0.062029   |   0.0 |  0.14
Other   |            | 0.005449   |            |       |  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:       130960 ave      130960 max      130960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130960
Ave neighs/atom = 65.48
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.374325826757, Press = -5.82064560828232
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8447.668      -8447.668      -8515.1881     -8515.1881      261.31007      261.31007      23321.167      23321.167      1545.2265      1545.2265    
     22000  -8447.6945     -8447.6945     -8513.38       -8513.38        254.20956      254.20956      23342.744      23342.744      230.5237       230.5237     
Loop time of 43.0357 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.008 ns/day, 11.954 hours/ns, 23.237 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    | 42.953     | 42.953     | 42.953     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.03
Output  | 4.2701e-05 | 4.2701e-05 | 4.2701e-05 |   0.0 |  0.00
Modify  | 0.06217    | 0.06217    | 0.06217    |   0.0 |  0.14
Other   |            | 0.005455   |            |       |  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:       131222 ave      131222 max      131222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131222
Ave neighs/atom = 65.611
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.426923702711, Press = 2.38526437795739
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8447.6945     -8447.6945     -8513.38       -8513.38        254.20956      254.20956      23342.744      23342.744      230.5237       230.5237     
     23000  -8448.526      -8448.526      -8513.4095     -8513.4095      251.10599      251.10599      23366.088      23366.088     -1437.8619     -1437.8619    
Loop time of 42.9935 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.010 ns/day, 11.943 hours/ns, 23.259 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    | 42.911     | 42.911     | 42.911     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015072   | 0.015072   | 0.015072   |   0.0 |  0.04
Output  | 4.3612e-05 | 4.3612e-05 | 4.3612e-05 |   0.0 |  0.00
Modify  | 0.062131   | 0.062131   | 0.062131   |   0.0 |  0.14
Other   |            | 0.005461   |            |       |  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:       131272 ave      131272 max      131272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131272
Ave neighs/atom = 65.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.33460766349, Press = -2.90589465573318
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8448.526      -8448.526      -8513.4095     -8513.4095      251.10599      251.10599      23366.088      23366.088     -1437.8619     -1437.8619    
     24000  -8447.1357     -8447.1357     -8512.8196     -8512.8196      254.20367      254.20367      23318.921      23318.921      2085.0674      2085.0674    
Loop time of 42.7478 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.021 ns/day, 11.874 hours/ns, 23.393 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    | 42.665     | 42.665     | 42.665     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015008   | 0.015008   | 0.015008   |   0.0 |  0.04
Output  | 3.6999e-05 | 3.6999e-05 | 3.6999e-05 |   0.0 |  0.00
Modify  | 0.061974   | 0.061974   | 0.061974   |   0.0 |  0.14
Other   |            | 0.005448   |            |       |  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:       131084 ave      131084 max      131084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131084
Ave neighs/atom = 65.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.391097337186, Press = 0.186457905962392
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8447.1357     -8447.1357     -8512.8196     -8512.8196      254.20367      254.20367      23318.921      23318.921      2085.0674      2085.0674    
     25000  -8450.3129     -8450.3129     -8513.8641     -8513.8641      245.94958      245.94958      23379.649      23379.649     -2506.1855     -2506.1855    
Loop time of 42.7363 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.871 hours/ns, 23.399 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    | 42.654     | 42.654     | 42.654     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.04
Output  | 2.9655e-05 | 2.9655e-05 | 2.9655e-05 |   0.0 |  0.00
Modify  | 0.061984   | 0.061984   | 0.061984   |   0.0 |  0.15
Other   |            | 0.005432   |            |       |  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:       131314 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657
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.325514962225, Press = -0.624934037794774
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8450.3129     -8450.3129     -8513.8641     -8513.8641      245.94958      245.94958      23379.649      23379.649     -2506.1855     -2506.1855    
     26000  -8445.9796     -8445.9796     -8511.8575     -8511.8575      254.95428      254.95428      23327.746      23327.746      1510.7714      1510.7714    
Loop time of 42.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.023 ns/day, 11.862 hours/ns, 23.418 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    | 42.619     | 42.619     | 42.619     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.04
Output  | 4.1769e-05 | 4.1769e-05 | 4.1769e-05 |   0.0 |  0.00
Modify  | 0.062092   | 0.062092   | 0.062092   |   0.0 |  0.15
Other   |            | 0.005463   |            |       |  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:       130904 ave      130904 max      130904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130904
Ave neighs/atom = 65.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 = 253.327416185185, Press = -1.72564826151868
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8445.9796     -8445.9796     -8511.8575     -8511.8575      254.95428      254.95428      23327.746      23327.746      1510.7714      1510.7714    
     27000  -8448.7854     -8448.7854     -8512.1644     -8512.1644      245.28336      245.28336      23348.235      23348.235     -53.372383     -53.372383    
Loop time of 42.9111 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.013 ns/day, 11.920 hours/ns, 23.304 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    | 42.828     | 42.828     | 42.828     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015056   | 0.015056   | 0.015056   |   0.0 |  0.04
Output  | 3.8101e-05 | 3.8101e-05 | 3.8101e-05 |   0.0 |  0.00
Modify  | 0.062178   | 0.062178   | 0.062178   |   0.0 |  0.14
Other   |            | 0.005476   |            |       |  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:       131256 ave      131256 max      131256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131256
Ave neighs/atom = 65.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 = 253.370134124878, Press = 0.475539057807833
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8448.7854     -8448.7854     -8512.1644     -8512.1644      245.28336      245.28336      23348.235      23348.235     -53.372383     -53.372383    
     28000  -8445.2926     -8445.2926     -8511.1823     -8511.1823      254.99998      254.99998      23348.718      23348.718      143.5897       143.5897     
Loop time of 42.8092 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.018 ns/day, 11.891 hours/ns, 23.359 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    | 42.727     | 42.727     | 42.727     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014989   | 0.014989   | 0.014989   |   0.0 |  0.04
Output  | 2.8854e-05 | 2.8854e-05 | 2.8854e-05 |   0.0 |  0.00
Modify  | 0.062067   | 0.062067   | 0.062067   |   0.0 |  0.14
Other   |            | 0.005437   |            |       |  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:       131156 ave      131156 max      131156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131156
Ave neighs/atom = 65.578
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.458381802165, Press = -1.78687888010815
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8445.2926     -8445.2926     -8511.1823     -8511.1823      254.99998      254.99998      23348.718      23348.718      143.5897       143.5897     
     29000  -8450.126      -8450.126      -8512.9617     -8512.9617      243.18089      243.18089      23333.87       23333.87       736.4617       736.4617     
Loop time of 42.9259 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.013 ns/day, 11.924 hours/ns, 23.296 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    | 42.843     | 42.843     | 42.843     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015064   | 0.015064   | 0.015064   |   0.0 |  0.04
Output  | 4.2069e-05 | 4.2069e-05 | 4.2069e-05 |   0.0 |  0.00
Modify  | 0.062223   | 0.062223   | 0.062223   |   0.0 |  0.14
Other   |            | 0.005476   |            |       |  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:       131288 ave      131288 max      131288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131288
Ave neighs/atom = 65.644
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.469241155281, Press = 0.36337390442099
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8450.126      -8450.126      -8512.9617     -8512.9617      243.18089      243.18089      23333.87       23333.87       736.4617       736.4617     
     30000  -8448.0598     -8448.0598     -8512.8203     -8512.8203      250.62974      250.62974      23375.814      23375.814     -2049.121      -2049.121     
Loop time of 43.0086 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.009 ns/day, 11.947 hours/ns, 23.251 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    | 42.926     | 42.926     | 42.926     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01504    | 0.01504    | 0.01504    |   0.0 |  0.03
Output  | 4.1047e-05 | 4.1047e-05 | 4.1047e-05 |   0.0 |  0.00
Modify  | 0.062072   | 0.062072   | 0.062072   |   0.0 |  0.14
Other   |            | 0.005424   |            |       |  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:       131442 ave      131442 max      131442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131442
Ave neighs/atom = 65.721
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.451113744836, Press = -2.27199484136592
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8448.0598     -8448.0598     -8512.8203     -8512.8203      250.62974      250.62974      23375.814      23375.814     -2049.121      -2049.121     
     31000  -8447.0904     -8447.0904     -8513.3264     -8513.3264      256.34036      256.34036      23300.11       23300.11       3224.1474      3224.1474    
Loop time of 42.8758 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.015 ns/day, 11.910 hours/ns, 23.323 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    | 42.793     | 42.793     | 42.793     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015027   | 0.015027   | 0.015027   |   0.0 |  0.04
Output  | 3.8382e-05 | 3.8382e-05 | 3.8382e-05 |   0.0 |  0.00
Modify  | 0.062164   | 0.062164   | 0.062164   |   0.0 |  0.14
Other   |            | 0.005441   |            |       |  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:       131092 ave      131092 max      131092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131092
Ave neighs/atom = 65.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 = 253.459953935075, Press = -0.0903763344433258
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8447.0904     -8447.0904     -8513.3264     -8513.3264      256.34036      256.34036      23300.11       23300.11       3224.1474      3224.1474    
     32000  -8444.447      -8444.447      -8511.7618     -8511.7618      260.51533      260.51533      23382.081      23382.081     -2192.5875     -2192.5875    
Loop time of 43.0611 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 42.978     | 42.978     | 42.978     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.03
Output  | 2.9927e-05 | 2.9927e-05 | 2.9927e-05 |   0.0 |  0.00
Modify  | 0.062202   | 0.062202   | 0.062202   |   0.0 |  0.14
Other   |            | 0.005433   |            |       |  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:       131662 ave      131662 max      131662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131662
Ave neighs/atom = 65.831
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.479495987433, Press = 0.452426166404707
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8444.447      -8444.447      -8511.7618     -8511.7618      260.51533      260.51533      23382.081      23382.081     -2192.5875     -2192.5875    
     33000  -8446.9223     -8446.9223     -8512.4114     -8512.4114      253.44983      253.44983      23327.456      23327.456      1370.5068      1370.5068    
Loop time of 42.8496 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.903 hours/ns, 23.337 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    | 42.767     | 42.767     | 42.767     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015074   | 0.015074   | 0.015074   |   0.0 |  0.04
Output  | 4.0626e-05 | 4.0626e-05 | 4.0626e-05 |   0.0 |  0.00
Modify  | 0.062258   | 0.062258   | 0.062258   |   0.0 |  0.15
Other   |            | 0.00545    |            |       |  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:       131134 ave      131134 max      131134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131134
Ave neighs/atom = 65.567
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.480715325472, Press = -1.798649982316
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8446.9223     -8446.9223     -8512.4114     -8512.4114      253.44983      253.44983      23327.456      23327.456      1370.5068      1370.5068    
     34000  -8449.8613     -8449.8613     -8514.4631     -8514.4631      250.01576      250.01576      23349.715      23349.715     -517.57844     -517.57844    
Loop time of 42.8265 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.896 hours/ns, 23.350 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    | 42.744     | 42.744     | 42.744     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015022   | 0.015022   | 0.015022   |   0.0 |  0.04
Output  | 4.0035e-05 | 4.0035e-05 | 4.0035e-05 |   0.0 |  0.00
Modify  | 0.062197   | 0.062197   | 0.062197   |   0.0 |  0.15
Other   |            | 0.005446   |            |       |  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:       131324 ave      131324 max      131324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131324
Ave neighs/atom = 65.662
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.410758990354, Press = 0.244038610104643
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8449.8613     -8449.8613     -8514.4631     -8514.4631      250.01576      250.01576      23349.715      23349.715     -517.57844     -517.57844    
     35000  -8449.2091     -8449.2091     -8514.2247     -8514.2247      251.61698      251.61698      23345.637      23345.637     -196.91557     -196.91557    
Loop time of 42.8341 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.898 hours/ns, 23.346 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    | 42.751     | 42.751     | 42.751     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.04
Output  | 3.1089e-05 | 3.1089e-05 | 3.1089e-05 |   0.0 |  0.00
Modify  | 0.062163   | 0.062163   | 0.062163   |   0.0 |  0.15
Other   |            | 0.005433   |            |       |  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:       131274 ave      131274 max      131274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131274
Ave neighs/atom = 65.637
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.420524111352, Press = -1.06485232550319
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8449.2091     -8449.2091     -8514.2247     -8514.2247      251.61698      251.61698      23345.637      23345.637     -196.91557     -196.91557    
     36000  -8446.957      -8446.957      -8512.335      -8512.335       253.01946      253.01946      23344.265      23344.265      248.96063      248.96063    
Loop time of 42.6919 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.024 ns/day, 11.859 hours/ns, 23.424 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    | 42.609     | 42.609     | 42.609     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.04
Output  | 4.0226e-05 | 4.0226e-05 | 4.0226e-05 |   0.0 |  0.00
Modify  | 0.062075   | 0.062075   | 0.062075   |   0.0 |  0.15
Other   |            | 0.00541    |            |       |  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:       131146 ave      131146 max      131146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131146
Ave neighs/atom = 65.573
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.435423808803, Press = -0.63883496305767
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8446.957      -8446.957      -8512.335      -8512.335       253.01946      253.01946      23344.265      23344.265      248.96063      248.96063    
     37000  -8452.4246     -8452.4246     -8516.2189     -8516.2189      246.89053      246.89053      23340.248      23340.248     -114.13171     -114.13171    
Loop time of 42.8975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.014 ns/day, 11.916 hours/ns, 23.311 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    | 42.815     | 42.815     | 42.815     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.03
Output  | 4.0857e-05 | 4.0857e-05 | 4.0857e-05 |   0.0 |  0.00
Modify  | 0.062004   | 0.062004   | 0.062004   |   0.0 |  0.14
Other   |            | 0.005433   |            |       |  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:       131192 ave      131192 max      131192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131192
Ave neighs/atom = 65.596
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.403894675528, Press = -0.161275505118632
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8452.4246     -8452.4246     -8516.2189     -8516.2189      246.89053      246.89053      23340.248      23340.248     -114.13171     -114.13171    
     38000  -8446.1383     -8446.1383     -8511.7078     -8511.7078      253.76063      253.76063      23345.247      23345.247      291.62275      291.62275    
Loop time of 42.6116 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.837 hours/ns, 23.468 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    | 42.529     | 42.529     | 42.529     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015022   | 0.015022   | 0.015022   |   0.0 |  0.04
Output  | 9.6501e-05 | 9.6501e-05 | 9.6501e-05 |   0.0 |  0.00
Modify  | 0.062159   | 0.062159   | 0.062159   |   0.0 |  0.15
Other   |            | 0.00542    |            |       |  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:       130970 ave      130970 max      130970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130970
Ave neighs/atom = 65.485
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.354060246999, Press = -2.25195645712319
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8446.1383     -8446.1383     -8511.7078     -8511.7078      253.76063      253.76063      23345.247      23345.247      291.62275      291.62275    
     39000  -8448.7075     -8448.7075     -8514.4827     -8514.4827      254.55673      254.55673      23334.798      23334.798      572.88752      572.88752    
Loop time of 42.9583 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.011 ns/day, 11.933 hours/ns, 23.278 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    | 42.876     | 42.876     | 42.876     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015078   | 0.015078   | 0.015078   |   0.0 |  0.04
Output  | 2.5508e-05 | 2.5508e-05 | 2.5508e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.14
Other   |            | 0.005419   |            |       |  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:       131228 ave      131228 max      131228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131228
Ave neighs/atom = 65.614
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.393548707583, Press = 1.70473406258202
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8448.7075     -8448.7075     -8514.4827     -8514.4827      254.55673      254.55673      23334.798      23334.798      572.88752      572.88752    
     40000  -8448.9016     -8448.9016     -8513.2933     -8513.2933      249.2026       249.2026       23367.004      23367.004     -1513.4356     -1513.4356    
Loop time of 42.8543 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.904 hours/ns, 23.335 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    | 42.772     | 42.772     | 42.772     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.03
Output  | 4.807e-05  | 4.807e-05  | 4.807e-05  |   0.0 |  0.00
Modify  | 0.062077   | 0.062077   | 0.062077   |   0.0 |  0.14
Other   |            | 0.005316   |            |       |  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:       131214 ave      131214 max      131214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131214
Ave neighs/atom = 65.607
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.433438782182, Press = -2.15658077815599
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8448.9016     -8448.9016     -8513.2933     -8513.2933      249.2026       249.2026       23367.004      23367.004     -1513.4356     -1513.4356    
     41000  -8448.2054     -8448.2054     -8513.8879     -8513.8879      254.19817      254.19817      23321.782      23321.782      1531.4766      1531.4766    
Loop time of 42.9418 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.012 ns/day, 11.928 hours/ns, 23.287 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    | 42.859     | 42.859     | 42.859     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015065   | 0.015065   | 0.015065   |   0.0 |  0.04
Output  | 3.9764e-05 | 3.9764e-05 | 3.9764e-05 |   0.0 |  0.00
Modify  | 0.062239   | 0.062239   | 0.062239   |   0.0 |  0.14
Other   |            | 0.005309   |            |       |  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:       130924 ave      130924 max      130924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130924
Ave neighs/atom = 65.462
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.421004624447, Press = 0.128225963917676
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8448.2054     -8448.2054     -8513.8879     -8513.8879      254.19817      254.19817      23321.782      23321.782      1531.4766      1531.4766    
     42000  -8448.487      -8448.487      -8513.1061     -8513.1061      250.08263      250.08263      23365.722      23365.722     -1407.224      -1407.224     
Loop time of 42.8516 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.903 hours/ns, 23.336 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    | 42.769     | 42.769     | 42.769     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.03
Output  | 2.5618e-05 | 2.5618e-05 | 2.5618e-05 |   0.0 |  0.00
Modify  | 0.06205    | 0.06205    | 0.06205    |   0.0 |  0.14
Other   |            | 0.005295   |            |       |  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:       131298 ave      131298 max      131298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131298
Ave neighs/atom = 65.649
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.403578211442, Press = -0.560520810755345
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8448.487      -8448.487      -8513.1061     -8513.1061      250.08263      250.08263      23365.722      23365.722     -1407.224      -1407.224     
     43000  -8445.6644     -8445.6644     -8510.958      -8510.958       252.69307      252.69307      23336.949      23336.949      1000.49        1000.49      
Loop time of 42.8282 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.897 hours/ns, 23.349 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    | 42.746     | 42.746     | 42.746     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01504    | 0.01504    | 0.01504    |   0.0 |  0.04
Output  | 4.4373e-05 | 4.4373e-05 | 4.4373e-05 |   0.0 |  0.00
Modify  | 0.062111   | 0.062111   | 0.062111   |   0.0 |  0.15
Other   |            | 0.005307   |            |       |  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:       131018 ave      131018 max      131018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131018
Ave neighs/atom = 65.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.3892664616, Press = -0.714026692748525
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8445.6644     -8445.6644     -8510.958      -8510.958       252.69307      252.69307      23336.949      23336.949      1000.49        1000.49      
     44000  -8449.5338     -8449.5338     -8514.8471     -8514.8471      252.769        252.769        23346.621      23346.621     -334.81664     -334.81664    
Loop time of 43.0232 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.008 ns/day, 11.951 hours/ns, 23.243 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    | 42.941     | 42.941     | 42.941     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.03
Output  | 4.2489e-05 | 4.2489e-05 | 4.2489e-05 |   0.0 |  0.00
Modify  | 0.062217   | 0.062217   | 0.062217   |   0.0 |  0.14
Other   |            | 0.005338   |            |       |  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:       131354 ave      131354 max      131354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131354
Ave neighs/atom = 65.677
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.383354654162, Press = -0.25307597649687
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8449.5338     -8449.5338     -8514.8471     -8514.8471      252.769        252.769        23346.621      23346.621     -334.81664     -334.81664    
     45000  -8444.7007     -8444.7007     -8513.3189     -8513.3189      265.5594       265.5594       23349.078      23349.078     -172.40122     -172.40122    
Loop time of 42.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.897 hours/ns, 23.348 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    | 42.747     | 42.747     | 42.747     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015101   | 0.015101   | 0.015101   |   0.0 |  0.04
Output  | 3.5256e-05 | 3.5256e-05 | 3.5256e-05 |   0.0 |  0.00
Modify  | 0.062078   | 0.062078   | 0.062078   |   0.0 |  0.14
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:       131136 ave      131136 max      131136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131136
Ave neighs/atom = 65.568
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.403412731802, Press = -1.08449499918263
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8444.7007     -8444.7007     -8513.3189     -8513.3189      265.5594       265.5594       23349.078      23349.078     -172.40122     -172.40122    
     46000  -8448.3526     -8448.3526     -8514.1916     -8514.1916      254.80373      254.80373      23346.049      23346.049     -157.45061     -157.45061    
Loop time of 43.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.004 ns/day, 11.974 hours/ns, 23.198 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    | 43.025     | 43.025     | 43.025     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015066   | 0.015066   | 0.015066   |   0.0 |  0.03
Output  | 2.4977e-05 | 2.4977e-05 | 2.4977e-05 |   0.0 |  0.00
Modify  | 0.062304   | 0.062304   | 0.062304   |   0.0 |  0.14
Other   |            | 0.005402   |            |       |  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:       131214 ave      131214 max      131214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131214
Ave neighs/atom = 65.607
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.434722072487, Press = 0.448503983871313
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8448.3526     -8448.3526     -8514.1916     -8514.1916      254.80373      254.80373      23346.049      23346.049     -157.45061     -157.45061    
     47000  -8449.2833     -8449.2833     -8514.5635     -8514.5635      252.64094      252.64094      23369.883      23369.883     -1951.449      -1951.449     
Loop time of 42.7607 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.021 ns/day, 11.878 hours/ns, 23.386 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    | 42.678     | 42.678     | 42.678     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015058   | 0.015058   | 0.015058   |   0.0 |  0.04
Output  | 4.2099e-05 | 4.2099e-05 | 4.2099e-05 |   0.0 |  0.00
Modify  | 0.062087   | 0.062087   | 0.062087   |   0.0 |  0.15
Other   |            | 0.005306   |            |       |  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:       131164 ave      131164 max      131164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131164
Ave neighs/atom = 65.582
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.454427034492, Press = -2.61091329627361
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8449.2833     -8449.2833     -8514.5635     -8514.5635      252.64094      252.64094      23369.883      23369.883     -1951.449      -1951.449     
     48000  -8446.7464     -8446.7464     -8514.2513     -8514.2513      261.25112      261.25112      23314.775      23314.775      2060.3684      2060.3684    
Loop time of 42.9871 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.010 ns/day, 11.941 hours/ns, 23.263 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    | 42.905     | 42.905     | 42.905     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.04
Output  | 3.6208e-05 | 3.6208e-05 | 3.6208e-05 |   0.0 |  0.00
Modify  | 0.062123   | 0.062123   | 0.062123   |   0.0 |  0.14
Other   |            | 0.005302   |            |       |  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:       130964 ave      130964 max      130964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 130964
Ave neighs/atom = 65.482
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.421025359008, Press = 0.528566367960527
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8446.7464     -8446.7464     -8514.2513     -8514.2513      261.25112      261.25112      23314.775      23314.775      2060.3684      2060.3684    
     49000  -8451.2434     -8451.2434     -8515.0814     -8515.0814      247.05974      247.05974      23367.311      23367.311     -1901.0911     -1901.0911    
Loop time of 43.035 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.008 ns/day, 11.954 hours/ns, 23.237 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    | 42.952     | 42.952     | 42.952     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01509    | 0.01509    | 0.01509    |   0.0 |  0.04
Output  | 2.5198e-05 | 2.5198e-05 | 2.5198e-05 |   0.0 |  0.00
Modify  | 0.062233   | 0.062233   | 0.062233   |   0.0 |  0.14
Other   |            | 0.005282   |            |       |  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:       131284 ave      131284 max      131284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131284
Ave neighs/atom = 65.642
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.369484595781, Press = -0.820298938438691
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8451.2434     -8451.2434     -8515.0814     -8515.0814      247.05974      247.05974      23367.311      23367.311     -1901.0911     -1901.0911    
     50000  -8449.0005     -8449.0005     -8515.3452     -8515.3452      256.76108      256.76108      23324.43       23324.43       1207.6314      1207.6314    
Loop time of 43.0005 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.009 ns/day, 11.945 hours/ns, 23.256 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    | 42.918     | 42.918     | 42.918     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.03
Output  | 3.8362e-05 | 3.8362e-05 | 3.8362e-05 |   0.0 |  0.00
Modify  | 0.062403   | 0.062403   | 0.062403   |   0.0 |  0.15
Other   |            | 0.005437   |            |       |  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:       131018 ave      131018 max      131018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131018
Ave neighs/atom = 65.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.359737257023, Press = -0.765478446615787
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8449.0005     -8449.0005     -8515.3452     -8515.3452      256.76108      256.76108      23324.43       23324.43       1207.6314      1207.6314    
     51000  -8446.489      -8446.489      -8513.477      -8513.477       259.25038      259.25038      23361.674      23361.674     -1146.5463     -1146.5463    
Loop time of 43.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.007 ns/day, 11.956 hours/ns, 23.233 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    | 42.959     | 42.959     | 42.959     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015059   | 0.015059   | 0.015059   |   0.0 |  0.03
Output  | 4.5876e-05 | 4.5876e-05 | 4.5876e-05 |   0.0 |  0.00
Modify  | 0.062322   | 0.062322   | 0.062322   |   0.0 |  0.14
Other   |            | 0.005457   |            |       |  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:       131200 ave      131200 max      131200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131200
Ave neighs/atom = 65.6
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.354512981915, Press = 0.229000455349423
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8446.489      -8446.489      -8513.477      -8513.477       259.25038      259.25038      23361.674      23361.674     -1146.5463     -1146.5463    
     52000  -8449.818      -8449.818      -8514.7472     -8514.7472      251.28274      251.28274      23331.461      23331.461      716.57655      716.57655    
Loop time of 42.8992 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.014 ns/day, 11.916 hours/ns, 23.310 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    | 42.816     | 42.816     | 42.816     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.04
Output  | 3.5436e-05 | 3.5436e-05 | 3.5436e-05 |   0.0 |  0.00
Modify  | 0.062291   | 0.062291   | 0.062291   |   0.0 |  0.15
Other   |            | 0.005447   |            |       |  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:       131064 ave      131064 max      131064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131064
Ave neighs/atom = 65.532
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.354015430383, Press = -1.78925189054428
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8449.818      -8449.818      -8514.7472     -8514.7472      251.28274      251.28274      23331.461      23331.461      716.57655      716.57655    
     53000  -8446.5519     -8446.5519     -8512.6146     -8512.6146      255.66948      255.66948      23344.32       23344.32       210.06472      210.06472    
Loop time of 43.3276 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.994 ns/day, 12.035 hours/ns, 23.080 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    | 43.245     | 43.245     | 43.245     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.03
Output  | 2.5007e-05 | 2.5007e-05 | 2.5007e-05 |   0.0 |  0.00
Modify  | 0.062213   | 0.062213   | 0.062213   |   0.0 |  0.14
Other   |            | 0.005311   |            |       |  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:       131192 ave      131192 max      131192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131192
Ave neighs/atom = 65.596
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.332291597347, Press = 1.58893011413151
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8446.5519     -8446.5519     -8512.6146     -8512.6146      255.66948      255.66948      23344.32       23344.32       210.06472      210.06472    
     54000  -8451.6809     -8451.6809     -8514.4333     -8514.4333      242.85815      242.85815      23355.097      23355.097     -1041.0935     -1041.0935    
Loop time of 43.2037 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.000 ns/day, 12.001 hours/ns, 23.146 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    | 43.121     | 43.121     | 43.121     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015036   | 0.015036   | 0.015036   |   0.0 |  0.03
Output  | 4.77e-05   | 4.77e-05   | 4.77e-05   |   0.0 |  0.00
Modify  | 0.062294   | 0.062294   | 0.062294   |   0.0 |  0.14
Other   |            | 0.005308   |            |       |  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:       131292 ave      131292 max      131292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131292
Ave neighs/atom = 65.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.301112866623, Press = -1.53691750134496
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8451.6809     -8451.6809     -8514.4333     -8514.4333      242.85815      242.85815      23355.097      23355.097     -1041.0935     -1041.0935    
     55000  -8447.6527     -8447.6527     -8511.9196     -8511.9196      248.71975      248.71975      23327.334      23327.334      1435.4149      1435.4149    
Loop time of 43.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.005 ns/day, 11.968 hours/ns, 23.210 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    | 43.002     | 43.002     | 43.002     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.03
Output  | 4.0245e-05 | 4.0245e-05 | 4.0245e-05 |   0.0 |  0.00
Modify  | 0.062061   | 0.062061   | 0.062061   |   0.0 |  0.14
Other   |            | 0.005402   |            |       |  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:       131020 ave      131020 max      131020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131020
Ave neighs/atom = 65.51
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
23345.5960727888

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0