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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.031088910996914*${_u_distance}
variable latticeconst_converted equal 3.031088910996914*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891099691
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.000 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ShimKoKim_2013_AlVH__MO_344724145339_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_344724145339_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10529.421     -10529.421     -10600         -10600          273.15         273.15         27848.129      27848.129      2707.0828      2707.0828    
      1000  -10453.201     -10453.201     -10529.545     -10529.545      295.45863      295.45863      28071.556      28071.556     -2538.7075     -2538.7075    
Loop time of 43.1803 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.001 ns/day, 11.995 hours/ns, 23.159 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.099     | 43.099     | 43.099     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015238   | 0.015238   | 0.015238   |   0.0 |  0.04
Output  | 0.00013857 | 0.00013857 | 0.00013857 |   0.0 |  0.00
Modify  | 0.06038    | 0.06038    | 0.06038    |   0.0 |  0.14
Other   |            | 0.005657   |            |       |  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:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10453.201     -10453.201     -10529.545     -10529.545      295.45863      295.45863      28071.556      28071.556     -2538.7075     -2538.7075    
      2000  -10456.006     -10456.006     -10529.297     -10529.297      283.64535      283.64535      28006.911      28006.911      1063.0819      1063.0819    
Loop time of 44.2882 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.951 ns/day, 12.302 hours/ns, 22.579 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    | 44.208     | 44.208     | 44.208     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.03
Output  | 5.7349e-05 | 5.7349e-05 | 5.7349e-05 |   0.0 |  0.00
Modify  | 0.059453   | 0.059453   | 0.059453   |   0.0 |  0.13
Other   |            | 0.005361   |            |       |  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:       222710 ave      222710 max      222710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222710
Ave neighs/atom = 111.355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10456.006     -10456.006     -10529.297     -10529.297      283.64535      283.64535      28006.911      28006.911      1063.0819      1063.0819    
      3000  -10455.792     -10455.792     -10526.15      -10526.15       272.29222      272.29222      28023.427      28023.427      428.61891      428.61891    
Loop time of 44.4083 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.336 hours/ns, 22.518 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    | 44.328     | 44.328     | 44.328     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015087   | 0.015087   | 0.015087   |   0.0 |  0.03
Output  | 5.5374e-05 | 5.5374e-05 | 5.5374e-05 |   0.0 |  0.00
Modify  | 0.059561   | 0.059561   | 0.059561   |   0.0 |  0.13
Other   |            | 0.005299   |            |       |  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:       222680 ave      222680 max      222680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222680
Ave neighs/atom = 111.34
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10455.792     -10455.792     -10526.15      -10526.15       272.29222      272.29222      28023.427      28023.427      428.61891      428.61891    
      4000  -10455.159     -10455.159     -10523.645     -10523.645      265.04481      265.04481      28036.601      28036.601     -479.80466     -479.80466    
Loop time of 44.4108 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.336 hours/ns, 22.517 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    | 44.331     | 44.331     | 44.331     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015103   | 0.015103   | 0.015103   |   0.0 |  0.03
Output  | 4.4715e-05 | 4.4715e-05 | 4.4715e-05 |   0.0 |  0.00
Modify  | 0.059526   | 0.059526   | 0.059526   |   0.0 |  0.13
Other   |            | 0.005287   |            |       |  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:       222522 ave      222522 max      222522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222522
Ave neighs/atom = 111.261
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10455.159     -10455.159     -10523.645     -10523.645      265.04481      265.04481      28036.601      28036.601     -479.80466     -479.80466    
      5000  -10455.351     -10455.351     -10523.985     -10523.985      265.62383      265.62383      28002.354      28002.354      1577.2486      1577.2486    
Loop time of 44.4119 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.337 hours/ns, 22.516 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    | 44.332     | 44.332     | 44.332     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014981   | 0.014981   | 0.014981   |   0.0 |  0.03
Output  | 4.1728e-05 | 4.1728e-05 | 4.1728e-05 |   0.0 |  0.00
Modify  | 0.059797   | 0.059797   | 0.059797   |   0.0 |  0.13
Other   |            | 0.005328   |            |       |  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:       222336 ave      222336 max      222336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222336
Ave neighs/atom = 111.168
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 = 275.643294305125, Press = -844.905173294717
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10455.351     -10455.351     -10523.985     -10523.985      265.62383      265.62383      28002.354      28002.354      1577.2486      1577.2486    
      6000  -10454.778     -10454.778     -10524.635     -10524.635      270.3539       270.3539       28068.948      28068.948     -2374.3704     -2374.3704    
Loop time of 44.4812 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.942 ns/day, 12.356 hours/ns, 22.481 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    | 44.399     | 44.399     | 44.399     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 4.4163e-05 | 4.4163e-05 | 4.4163e-05 |   0.0 |  0.00
Modify  | 0.061926   | 0.061926   | 0.061926   |   0.0 |  0.14
Other   |            | 0.005352   |            |       |  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:       222492 ave      222492 max      222492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222492
Ave neighs/atom = 111.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.764409086297, Press = -12.1624298543151
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10454.778     -10454.778     -10524.635     -10524.635      270.3539       270.3539       28068.948      28068.948     -2374.3704     -2374.3704    
      7000  -10457.055     -10457.055     -10530.157     -10530.157      282.91312      282.91312      27977.846      27977.846      2525.388       2525.388     
Loop time of 44.4031 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.334 hours/ns, 22.521 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    | 44.321     | 44.321     | 44.321     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014968   | 0.014968   | 0.014968   |   0.0 |  0.03
Output  | 4.4003e-05 | 4.4003e-05 | 4.4003e-05 |   0.0 |  0.00
Modify  | 0.061942   | 0.061942   | 0.061942   |   0.0 |  0.14
Other   |            | 0.005363   |            |       |  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:       222324 ave      222324 max      222324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222324
Ave neighs/atom = 111.162
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.11184226027, Press = -22.2491418156699
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10457.055     -10457.055     -10530.157     -10530.157      282.91312      282.91312      27977.846      27977.846      2525.388       2525.388     
      8000  -10453.844     -10453.844     -10527.611     -10527.611      285.48699      285.48699      28055.691      28055.691     -1464.8583     -1464.8583    
Loop time of 44.3906 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.331 hours/ns, 22.527 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    | 44.308     | 44.308     | 44.308     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.03
Output  | 3.6248e-05 | 3.6248e-05 | 3.6248e-05 |   0.0 |  0.00
Modify  | 0.062005   | 0.062005   | 0.062005   |   0.0 |  0.14
Other   |            | 0.005349   |            |       |  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:       222834 ave      222834 max      222834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222834
Ave neighs/atom = 111.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.236105820105, Press = -15.1277327105049
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10453.844     -10453.844     -10527.611     -10527.611      285.48699      285.48699      28055.691      28055.691     -1464.8583     -1464.8583    
      9000  -10456.37      -10456.37      -10526.868     -10526.868      272.83275      272.83275      28014.362      28014.362      499.78442      499.78442    
Loop time of 44.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.941 ns/day, 12.363 hours/ns, 22.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    | 44.425     | 44.425     | 44.425     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.03
Output  | 4.4894e-05 | 4.4894e-05 | 4.4894e-05 |   0.0 |  0.00
Modify  | 0.062018   | 0.062018   | 0.062018   |   0.0 |  0.14
Other   |            | 0.005357   |            |       |  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:       222686 ave      222686 max      222686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222686
Ave neighs/atom = 111.343
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.328496810459, Press = -7.40355823302934
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10456.37      -10456.37      -10526.868     -10526.868      272.83275      272.83275      28014.362      28014.362      499.78442      499.78442    
     10000  -10455.1       -10455.1       -10524.608     -10524.608      269.00484      269.00484      28033.545      28033.545     -199.28229     -199.28229    
Loop time of 44.4759 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.943 ns/day, 12.354 hours/ns, 22.484 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    | 44.393     | 44.393     | 44.393     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015069   | 0.015069   | 0.015069   |   0.0 |  0.03
Output  | 4.9143e-05 | 4.9143e-05 | 4.9143e-05 |   0.0 |  0.00
Modify  | 0.061959   | 0.061959   | 0.061959   |   0.0 |  0.14
Other   |            | 0.005369   |            |       |  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:       222474 ave      222474 max      222474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222474
Ave neighs/atom = 111.237
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.155750464612, Press = -11.2849290499368
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10455.1       -10455.1       -10524.608     -10524.608      269.00484      269.00484      28033.545      28033.545     -199.28229     -199.28229    
     11000  -10456.133     -10456.133     -10524.276     -10524.276      263.71834      263.71834      28023.314      28023.314      360.2878       360.2878     
Loop time of 44.389 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.330 hours/ns, 22.528 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    | 44.307     | 44.307     | 44.307     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015054   | 0.015054   | 0.015054   |   0.0 |  0.03
Output  | 4.1628e-05 | 4.1628e-05 | 4.1628e-05 |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.14
Other   |            | 0.005365   |            |       |  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:       222376 ave      222376 max      222376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222376
Ave neighs/atom = 111.188
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.133877257422, Press = -5.35252528878641
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10456.133     -10456.133     -10524.276     -10524.276      263.71834      263.71834      28023.314      28023.314      360.2878       360.2878     
     12000  -10456.388     -10456.388     -10525.53      -10525.53       267.58567      267.58567      28026.86       28026.86       221.13112      221.13112    
Loop time of 44.3433 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.261     | 44.261     | 44.261     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014978   | 0.014978   | 0.014978   |   0.0 |  0.03
Output  | 2.5187e-05 | 2.5187e-05 | 2.5187e-05 |   0.0 |  0.00
Modify  | 0.061911   | 0.061911   | 0.061911   |   0.0 |  0.14
Other   |            | 0.005312   |            |       |  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:       222476 ave      222476 max      222476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222476
Ave neighs/atom = 111.238
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.159224807405, Press = -8.53242082839516
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10456.388     -10456.388     -10525.53      -10525.53       267.58567      267.58567      28026.86       28026.86       221.13112      221.13112    
     13000  -10458.725     -10458.725     -10527.302     -10527.302      265.40057      265.40057      28028.689      28028.689     -298.42669     -298.42669    
Loop time of 44.3427 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.948 ns/day, 12.317 hours/ns, 22.552 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    | 44.26      | 44.26      | 44.26      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015003   | 0.015003   | 0.015003   |   0.0 |  0.03
Output  | 3.0067e-05 | 3.0067e-05 | 3.0067e-05 |   0.0 |  0.00
Modify  | 0.061939   | 0.061939   | 0.061939   |   0.0 |  0.14
Other   |            | 0.005355   |            |       |  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:       222586 ave      222586 max      222586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222586
Ave neighs/atom = 111.293
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.223359023494, Press = -4.59878660233105
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10458.725     -10458.725     -10527.302     -10527.302      265.40057      265.40057      28028.689      28028.689     -298.42669     -298.42669    
     14000  -10454.737     -10454.737     -10526.389     -10526.389      277.30118      277.30118      28014.847      28014.847      670.79731      670.79731    
Loop time of 44.5455 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.940 ns/day, 12.374 hours/ns, 22.449 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    | 44.463     | 44.463     | 44.463     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.03
Output  | 5.5024e-05 | 5.5024e-05 | 5.5024e-05 |   0.0 |  0.00
Modify  | 0.061917   | 0.061917   | 0.061917   |   0.0 |  0.14
Other   |            | 0.005374   |            |       |  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:       222662 ave      222662 max      222662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222662
Ave neighs/atom = 111.331
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.043416381702, Press = -6.97139323114692
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10454.737     -10454.737     -10526.389     -10526.389      277.30118      277.30118      28014.847      28014.847      670.79731      670.79731    
     15000  -10455.799     -10455.799     -10526.134     -10526.134      272.20371      272.20371      28066.514      28066.514     -2166.6212     -2166.6212    
Loop time of 44.4374 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.944 ns/day, 12.344 hours/ns, 22.504 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    | 44.355     | 44.355     | 44.355     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.03
Output  | 2.673e-05  | 2.673e-05  | 2.673e-05  |   0.0 |  0.00
Modify  | 0.061927   | 0.061927   | 0.061927   |   0.0 |  0.14
Other   |            | 0.005364   |            |       |  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:       222594 ave      222594 max      222594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222594
Ave neighs/atom = 111.297
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.000881553252, Press = -5.24802060731305
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10455.799     -10455.799     -10526.134     -10526.134      272.20371      272.20371      28066.514      28066.514     -2166.6212     -2166.6212    
     16000  -10453.691     -10453.691     -10521.29      -10521.29       261.61673      261.61673      27978.413      27978.413      2931.7664      2931.7664    
Loop time of 44.3261 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.313 hours/ns, 22.560 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    | 44.244     | 44.244     | 44.244     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.03
Output  | 2.1891e-05 | 2.1891e-05 | 2.1891e-05 |   0.0 |  0.00
Modify  | 0.061932   | 0.061932   | 0.061932   |   0.0 |  0.14
Other   |            | 0.005357   |            |       |  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:       222464 ave      222464 max      222464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222464
Ave neighs/atom = 111.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.251977261291, Press = -2.82873252627952
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10453.691     -10453.691     -10521.29      -10521.29       261.61673      261.61673      27978.413      27978.413      2931.7664      2931.7664    
     17000  -10456.239     -10456.239     -10526.999     -10526.999      273.84916      273.84916      28065.513      28065.513     -2095.1925     -2095.1925    
Loop time of 44.3455 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.948 ns/day, 12.318 hours/ns, 22.550 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    | 44.263     | 44.263     | 44.263     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.03
Output  | 2.9736e-05 | 2.9736e-05 | 2.9736e-05 |   0.0 |  0.00
Modify  | 0.061913   | 0.061913   | 0.061913   |   0.0 |  0.14
Other   |            | 0.005368   |            |       |  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:       222422 ave      222422 max      222422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222422
Ave neighs/atom = 111.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.332910965113, Press = -6.19455566891562
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10456.239     -10456.239     -10526.999     -10526.999      273.84916      273.84916      28065.513      28065.513     -2095.1925     -2095.1925    
     18000  -10454.623     -10454.623     -10524.572     -10524.572      270.71097      270.71097      28018.623      28018.623      558.07173      558.07173    
Loop time of 44.3912 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.331 hours/ns, 22.527 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    | 44.309     | 44.309     | 44.309     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.03
Output  | 2.9616e-05 | 2.9616e-05 | 2.9616e-05 |   0.0 |  0.00
Modify  | 0.061869   | 0.061869   | 0.061869   |   0.0 |  0.14
Other   |            | 0.005385   |            |       |  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:       222488 ave      222488 max      222488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222488
Ave neighs/atom = 111.244
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463967248863, Press = -2.1512140690172
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10454.623     -10454.623     -10524.572     -10524.572      270.71097      270.71097      28018.623      28018.623      558.07173      558.07173    
     19000  -10459.402     -10459.402     -10527.091     -10527.091      261.9646       261.9646       28023.813      28023.813      37.429166      37.429166    
Loop time of 44.4631 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.943 ns/day, 12.351 hours/ns, 22.491 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    | 44.381     | 44.381     | 44.381     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014997   | 0.014997   | 0.014997   |   0.0 |  0.03
Output  | 2.159e-05  | 2.159e-05  | 2.159e-05  |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.14
Other   |            | 0.005331   |            |       |  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:       222476 ave      222476 max      222476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222476
Ave neighs/atom = 111.238
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.331560654637, Press = -4.44326055962356
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10459.402     -10459.402     -10527.091     -10527.091      261.9646       261.9646       28023.813      28023.813      37.429166      37.429166    
     20000  -10455.383     -10455.383     -10526.865     -10526.865      276.6399       276.6399       28032.903      28032.903     -298.32353     -298.32353    
Loop time of 44.4754 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.943 ns/day, 12.354 hours/ns, 22.484 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    | 44.393     | 44.393     | 44.393     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.03
Output  | 3.0557e-05 | 3.0557e-05 | 3.0557e-05 |   0.0 |  0.00
Modify  | 0.061971   | 0.061971   | 0.061971   |   0.0 |  0.14
Other   |            | 0.00534    |            |       |  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:       222592 ave      222592 max      222592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222592
Ave neighs/atom = 111.296
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.215769748446, Press = -3.81421918162528
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10455.383     -10455.383     -10526.865     -10526.865      276.6399       276.6399       28032.903      28032.903     -298.32353     -298.32353    
     21000  -10457.241     -10457.241     -10525.685     -10525.685      264.8856       264.8856       28014.027      28014.027      609.92699      609.92699    
Loop time of 44.4228 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.340 hours/ns, 22.511 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    | 44.341     | 44.341     | 44.341     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.03
Output  | 3.0698e-05 | 3.0698e-05 | 3.0698e-05 |   0.0 |  0.00
Modify  | 0.061874   | 0.061874   | 0.061874   |   0.0 |  0.14
Other   |            | 0.005357   |            |       |  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:       222598 ave      222598 max      222598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222598
Ave neighs/atom = 111.299
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.209358925581, Press = -3.10926580109111
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10457.241     -10457.241     -10525.685     -10525.685      264.8856       264.8856       28014.027      28014.027      609.92699      609.92699    
     22000  -10455.263     -10455.263     -10525.26      -10525.26       270.89618      270.89618      28044.997      28044.997     -1030.6272     -1030.6272    
Loop time of 44.3865 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.947 ns/day, 12.330 hours/ns, 22.529 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    | 44.304     | 44.304     | 44.304     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015008   | 0.015008   | 0.015008   |   0.0 |  0.03
Output  | 3.0097e-05 | 3.0097e-05 | 3.0097e-05 |   0.0 |  0.00
Modify  | 0.06194    | 0.06194    | 0.06194    |   0.0 |  0.14
Other   |            | 0.005323   |            |       |  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:       222482 ave      222482 max      222482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222482
Ave neighs/atom = 111.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.293779162634, Press = -3.23113666813277
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10455.263     -10455.263     -10525.26      -10525.26       270.89618      270.89618      28044.997      28044.997     -1030.6272     -1030.6272    
     23000  -10455.186     -10455.186     -10526.144     -10526.144      274.61499      274.61499      28006.234      28006.234      1106.1836      1106.1836    
Loop time of 44.4798 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.942 ns/day, 12.356 hours/ns, 22.482 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    | 44.398     | 44.398     | 44.398     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.03
Output  | 2.131e-05  | 2.131e-05  | 2.131e-05  |   0.0 |  0.00
Modify  | 0.061919   | 0.061919   | 0.061919   |   0.0 |  0.14
Other   |            | 0.005333   |            |       |  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:       222414 ave      222414 max      222414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222414
Ave neighs/atom = 111.207
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.359852515463, Press = -1.83404149969844
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10455.186     -10455.186     -10526.144     -10526.144      274.61499      274.61499      28006.234      28006.234      1106.1836      1106.1836    
     24000  -10452.119     -10452.119     -10523.278     -10523.278      275.39252      275.39252      28051.094      28051.094     -1026.376      -1026.376     
Loop time of 44.3358 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.315 hours/ns, 22.555 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    | 44.253     | 44.253     | 44.253     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015135   | 0.015135   | 0.015135   |   0.0 |  0.03
Output  | 0.00011498 | 0.00011498 | 0.00011498 |   0.0 |  0.00
Modify  | 0.062135   | 0.062135   | 0.062135   |   0.0 |  0.14
Other   |            | 0.005639   |            |       |  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:       222600 ave      222600 max      222600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222600
Ave neighs/atom = 111.3
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.51204845799, Press = -5.1687874275059
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10452.119     -10452.119     -10523.278     -10523.278      275.39252      275.39252      28051.094      28051.094     -1026.376      -1026.376     
     25000  -10455.816     -10455.816     -10526.375     -10526.375      273.07243      273.07243      28022.604      28022.604      143.9125       143.9125     
Loop time of 44.3975 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.333 hours/ns, 22.524 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    | 44.314     | 44.314     | 44.314     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015219   | 0.015219   | 0.015219   |   0.0 |  0.03
Output  | 6.5494e-05 | 6.5494e-05 | 6.5494e-05 |   0.0 |  0.00
Modify  | 0.062218   | 0.062218   | 0.062218   |   0.0 |  0.14
Other   |            | 0.005869   |            |       |  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:       222222 ave      222222 max      222222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222222
Ave neighs/atom = 111.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.530060917206, Press = -0.257852144823144
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10455.816     -10455.816     -10526.375     -10526.375      273.07243      273.07243      28022.604      28022.604      143.9125       143.9125     
     26000  -10455.818     -10455.818     -10524.364     -10524.364      265.28099      265.28099      28013.586      28013.586      868.00606      868.00606    
Loop time of 44.4196 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.339 hours/ns, 22.513 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    | 44.336     | 44.336     | 44.336     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015182   | 0.015182   | 0.015182   |   0.0 |  0.03
Output  | 3.0978e-05 | 3.0978e-05 | 3.0978e-05 |   0.0 |  0.00
Modify  | 0.062279   | 0.062279   | 0.062279   |   0.0 |  0.14
Other   |            | 0.006159   |            |       |  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:       222504 ave      222504 max      222504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222504
Ave neighs/atom = 111.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.607671220891, Press = -5.30749831899179
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10455.818     -10455.818     -10524.364     -10524.364      265.28099      265.28099      28013.586      28013.586      868.00606      868.00606    
     27000  -10455.482     -10455.482     -10525.433     -10525.433      270.71704      270.71704      28044.559      28044.559     -964.62461     -964.62461    
Loop time of 44.3704 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.947 ns/day, 12.325 hours/ns, 22.538 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    | 44.287     | 44.287     | 44.287     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015333   | 0.015333   | 0.015333   |   0.0 |  0.03
Output  | 2.173e-05  | 2.173e-05  | 2.173e-05  |   0.0 |  0.00
Modify  | 0.062246   | 0.062246   | 0.062246   |   0.0 |  0.14
Other   |            | 0.006236   |            |       |  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:       222492 ave      222492 max      222492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222492
Ave neighs/atom = 111.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.52577743268, Press = -0.912011284087687
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10455.482     -10455.482     -10525.433     -10525.433      270.71704      270.71704      28044.559      28044.559     -964.62461     -964.62461    
     28000  -10454.331     -10454.331     -10526.378     -10526.378      278.82922      278.82922      28020.594      28020.594      335.22866      335.22866    
Loop time of 44.4343 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.944 ns/day, 12.343 hours/ns, 22.505 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    | 44.35      | 44.35      | 44.35      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015472   | 0.015472   | 0.015472   |   0.0 |  0.03
Output  | 3.185e-05  | 3.185e-05  | 3.185e-05  |   0.0 |  0.00
Modify  | 0.062578   | 0.062578   | 0.062578   |   0.0 |  0.14
Other   |            | 0.006485   |            |       |  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:       222446 ave      222446 max      222446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222446
Ave neighs/atom = 111.223
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.527323961005, Press = -2.96976576912426
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10454.331     -10454.331     -10526.378     -10526.378      278.82922      278.82922      28020.594      28020.594      335.22866      335.22866    
     29000  -10454.958     -10454.958     -10525.504     -10525.504      273.01907      273.01907      28038.666      28038.666     -597.74417     -597.74417    
Loop time of 44.4083 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.336 hours/ns, 22.518 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    | 44.325     | 44.325     | 44.325     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.03
Output  | 2.9355e-05 | 2.9355e-05 | 2.9355e-05 |   0.0 |  0.00
Modify  | 0.062179   | 0.062179   | 0.062179   |   0.0 |  0.14
Other   |            | 0.005844   |            |       |  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:       222540 ave      222540 max      222540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222540
Ave neighs/atom = 111.27
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.50413726708, Press = -2.14541113690343
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10454.958     -10454.958     -10525.504     -10525.504      273.01907      273.01907      28038.666      28038.666     -597.74417     -597.74417    
     30000  -10454.363     -10454.363     -10524.074     -10524.074      269.7871       269.7871       28013.09       28013.09       1009.7891      1009.7891    
Loop time of 44.3284 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.313 hours/ns, 22.559 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    | 44.245     | 44.245     | 44.245     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015327   | 0.015327   | 0.015327   |   0.0 |  0.03
Output  | 2.9325e-05 | 2.9325e-05 | 2.9325e-05 |   0.0 |  0.00
Modify  | 0.062299   | 0.062299   | 0.062299   |   0.0 |  0.14
Other   |            | 0.006098   |            |       |  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:       222398 ave      222398 max      222398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222398
Ave neighs/atom = 111.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.583041447162, Press = -2.38934593654964
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10454.363     -10454.363     -10524.074     -10524.074      269.7871       269.7871       28013.09       28013.09       1009.7891      1009.7891    
     31000  -10454.212     -10454.212     -10525.609     -10525.609      276.31335      276.31335      28052.811      28052.811     -1345.7456     -1345.7456    
Loop time of 44.4032 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.334 hours/ns, 22.521 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    | 44.319     | 44.319     | 44.319     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015306   | 0.015306   | 0.015306   |   0.0 |  0.03
Output  | 2.1791e-05 | 2.1791e-05 | 2.1791e-05 |   0.0 |  0.00
Modify  | 0.06235    | 0.06235    | 0.06235    |   0.0 |  0.14
Other   |            | 0.006382   |            |       |  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:       222412 ave      222412 max      222412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222412
Ave neighs/atom = 111.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.598483654366, Press = -3.12488683189715
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10454.212     -10454.212     -10525.609     -10525.609      276.31335      276.31335      28052.811      28052.811     -1345.7456     -1345.7456    
     32000  -10456.215     -10456.215     -10526.491     -10526.491      271.97341      271.97341      28002.805      28002.805      1208.1178      1208.1178    
Loop time of 44.3129 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.950 ns/day, 12.309 hours/ns, 22.567 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    | 44.229     | 44.229     | 44.229     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015273   | 0.015273   | 0.015273   |   0.0 |  0.03
Output  | 2.8494e-05 | 2.8494e-05 | 2.8494e-05 |   0.0 |  0.00
Modify  | 0.062258   | 0.062258   | 0.062258   |   0.0 |  0.14
Other   |            | 0.006105   |            |       |  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:       222366 ave      222366 max      222366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222366
Ave neighs/atom = 111.183
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.676285194388, Press = -0.589094821444114
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10456.215     -10456.215     -10526.491     -10526.491      271.97341      271.97341      28002.805      28002.805      1208.1178      1208.1178    
     33000  -10455.726     -10455.726     -10526.774     -10526.774      274.96488      274.96488      28041.213      28041.213     -785.6928      -785.6928     
Loop time of 44.3927 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.331 hours/ns, 22.526 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    | 44.309     | 44.309     | 44.309     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015173   | 0.015173   | 0.015173   |   0.0 |  0.03
Output  | 2.8764e-05 | 2.8764e-05 | 2.8764e-05 |   0.0 |  0.00
Modify  | 0.062185   | 0.062185   | 0.062185   |   0.0 |  0.14
Other   |            | 0.006159   |            |       |  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:       222486 ave      222486 max      222486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222486
Ave neighs/atom = 111.243
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.686441686694, Press = -4.18858835643388
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10455.726     -10455.726     -10526.774     -10526.774      274.96488      274.96488      28041.213      28041.213     -785.6928      -785.6928     
     34000  -10455.08      -10455.08      -10526.484     -10526.484      276.34221      276.34221      28030.185      28030.185     -142.46297     -142.46297    
Loop time of 44.3573 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.948 ns/day, 12.321 hours/ns, 22.544 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    | 44.274     | 44.274     | 44.274     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015047   | 0.015047   | 0.015047   |   0.0 |  0.03
Output  | 2.8755e-05 | 2.8755e-05 | 2.8755e-05 |   0.0 |  0.00
Modify  | 0.062029   | 0.062029   | 0.062029   |   0.0 |  0.14
Other   |            | 0.005755   |            |       |  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:       222598 ave      222598 max      222598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222598
Ave neighs/atom = 111.299
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.709664421732, Press = 0.025258488137096
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10455.08      -10455.08      -10526.484     -10526.484      276.34221      276.34221      28030.185      28030.185     -142.46297     -142.46297    
     35000  -10457.818     -10457.818     -10527.625     -10527.625      270.16182      270.16182      28016.185      28016.185      399.24839      399.24839    
Loop time of 44.3928 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.331 hours/ns, 22.526 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    | 44.309     | 44.309     | 44.309     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01525    | 0.01525    | 0.01525    |   0.0 |  0.03
Output  | 2.1941e-05 | 2.1941e-05 | 2.1941e-05 |   0.0 |  0.00
Modify  | 0.062194   | 0.062194   | 0.062194   |   0.0 |  0.14
Other   |            | 0.005875   |            |       |  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:       222602 ave      222602 max      222602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222602
Ave neighs/atom = 111.301
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.670728006635, Press = -2.78047610622656
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10457.818     -10457.818     -10527.625     -10527.625      270.16182      270.16182      28016.185      28016.185      399.24839      399.24839    
     36000  -10454.87      -10454.87      -10525.935     -10525.935      275.02777      275.02777      28035.017      28035.017     -350.34758     -350.34758    
Loop time of 44.3005 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.950 ns/day, 12.306 hours/ns, 22.573 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    | 44.217     | 44.217     | 44.217     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015157   | 0.015157   | 0.015157   |   0.0 |  0.03
Output  | 2.8694e-05 | 2.8694e-05 | 2.8694e-05 |   0.0 |  0.00
Modify  | 0.062113   | 0.062113   | 0.062113   |   0.0 |  0.14
Other   |            | 0.005866   |            |       |  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:       222562 ave      222562 max      222562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222562
Ave neighs/atom = 111.281
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.659070971277, Press = -1.56717617065614
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10454.87      -10454.87      -10525.935     -10525.935      275.02777      275.02777      28035.017      28035.017     -350.34758     -350.34758    
     37000  -10458.211     -10458.211     -10529.579     -10529.579      276.20378      276.20378      28016.172      28016.172      217.92994      217.92994    
Loop time of 44.2819 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.951 ns/day, 12.301 hours/ns, 22.583 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    | 44.199     | 44.199     | 44.199     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015218   | 0.015218   | 0.015218   |   0.0 |  0.03
Output  | 2.9174e-05 | 2.9174e-05 | 2.9174e-05 |   0.0 |  0.00
Modify  | 0.062107   | 0.062107   | 0.062107   |   0.0 |  0.14
Other   |            | 0.0058     |            |       |  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:       222562 ave      222562 max      222562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222562
Ave neighs/atom = 111.281
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.556711029016, Press = -2.17133935493383
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10458.211     -10458.211     -10529.579     -10529.579      276.20378      276.20378      28016.172      28016.172      217.92994      217.92994    
     38000  -10455.242     -10455.242     -10524.565     -10524.565      268.28722      268.28722      28055.861      28055.861     -1328.7191     -1328.7191    
Loop time of 44.4003 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.333 hours/ns, 22.522 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    | 44.317     | 44.317     | 44.317     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015063   | 0.015063   | 0.015063   |   0.0 |  0.03
Output  | 2.1411e-05 | 2.1411e-05 | 2.1411e-05 |   0.0 |  0.00
Modify  | 0.061973   | 0.061973   | 0.061973   |   0.0 |  0.14
Other   |            | 0.005733   |            |       |  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:       222730 ave      222730 max      222730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222730
Ave neighs/atom = 111.365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.566415627539, Press = -1.9444914639837
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10455.242     -10455.242     -10524.565     -10524.565      268.28722      268.28722      28055.861      28055.861     -1328.7191     -1328.7191    
     39000  -10455.768     -10455.768     -10526.569     -10526.569      274.00355      274.00355      27963.447      27963.447      3485.9413      3485.9413    
Loop time of 44.3192 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.311 hours/ns, 22.564 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    | 44.237     | 44.237     | 44.237     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.03
Output  | 3.3463e-05 | 3.3463e-05 | 3.3463e-05 |   0.0 |  0.00
Modify  | 0.06192    | 0.06192    | 0.06192    |   0.0 |  0.14
Other   |            | 0.005647   |            |       |  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:       222366 ave      222366 max      222366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222366
Ave neighs/atom = 111.183
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.590850240446, Press = -0.999909800528123
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10455.768     -10455.768     -10526.569     -10526.569      274.00355      274.00355      27963.447      27963.447      3485.9413      3485.9413    
     40000  -10455.494     -10455.494     -10525.538     -10525.538      271.08018      271.08018      28059.907      28059.907     -1768.0201     -1768.0201    
Loop time of 44.3528 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.948 ns/day, 12.320 hours/ns, 22.546 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    | 44.27      | 44.27      | 44.27      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015067   | 0.015067   | 0.015067   |   0.0 |  0.03
Output  | 2.9205e-05 | 2.9205e-05 | 2.9205e-05 |   0.0 |  0.00
Modify  | 0.061984   | 0.061984   | 0.061984   |   0.0 |  0.14
Other   |            | 0.005745   |            |       |  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:       222744 ave      222744 max      222744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222744
Ave neighs/atom = 111.372
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.587667520724, Press = -2.58437298133602
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10455.494     -10455.494     -10525.538     -10525.538      271.08018      271.08018      28059.907      28059.907     -1768.0201     -1768.0201    
     41000  -10457.717     -10457.717     -10526.798     -10526.798      267.35146      267.35146      28008.146      28008.146      966.9494       966.9494     
Loop time of 44.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.944 ns/day, 12.346 hours/ns, 22.500 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    | 44.362     | 44.362     | 44.362     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015069   | 0.015069   | 0.015069   |   0.0 |  0.03
Output  | 3.3303e-05 | 3.3303e-05 | 3.3303e-05 |   0.0 |  0.00
Modify  | 0.062047   | 0.062047   | 0.062047   |   0.0 |  0.14
Other   |            | 0.005775   |            |       |  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:       222508 ave      222508 max      222508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222508
Ave neighs/atom = 111.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.515070358537, Press = -0.750369504990811
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10457.717     -10457.717     -10526.798     -10526.798      267.35146      267.35146      28008.146      28008.146      966.9494       966.9494     
     42000  -10456.589     -10456.589     -10527.528     -10527.528      274.53915      274.53915      28032.859      28032.859     -402.55848     -402.55848    
Loop time of 44.4291 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.341 hours/ns, 22.508 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    | 44.346     | 44.346     | 44.346     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.03
Output  | 2.1882e-05 | 2.1882e-05 | 2.1882e-05 |   0.0 |  0.00
Modify  | 0.062067   | 0.062067   | 0.062067   |   0.0 |  0.14
Other   |            | 0.005866   |            |       |  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:       222644 ave      222644 max      222644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222644
Ave neighs/atom = 111.322
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.515706186118, Press = -2.26668099930001
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10456.589     -10456.589     -10527.528     -10527.528      274.53915      274.53915      28032.859      28032.859     -402.55848     -402.55848    
     43000  -10453.853     -10453.853     -10525.595     -10525.595      277.64808      277.64808      28029.216      28029.216     -25.936664     -25.936664    
Loop time of 44.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.314 hours/ns, 22.558 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    | 44.247     | 44.247     | 44.247     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015024   | 0.015024   | 0.015024   |   0.0 |  0.03
Output  | 2.8394e-05 | 2.8394e-05 | 2.8394e-05 |   0.0 |  0.00
Modify  | 0.061988   | 0.061988   | 0.061988   |   0.0 |  0.14
Other   |            | 0.005747   |            |       |  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:       222664 ave      222664 max      222664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222664
Ave neighs/atom = 111.332
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.540459834846, Press = -0.8792241464216
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10453.853     -10453.853     -10525.595     -10525.595      277.64808      277.64808      28029.216      28029.216     -25.936664     -25.936664    
     44000  -10458.12      -10458.12      -10525.361     -10525.361      260.22885      260.22885      28001.702      28001.702      1294.3905      1294.3905    
Loop time of 44.4254 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.945 ns/day, 12.340 hours/ns, 22.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    | 44.343     | 44.343     | 44.343     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015111   | 0.015111   | 0.015111   |   0.0 |  0.03
Output  | 2.9135e-05 | 2.9135e-05 | 2.9135e-05 |   0.0 |  0.00
Modify  | 0.062033   | 0.062033   | 0.062033   |   0.0 |  0.14
Other   |            | 0.005618   |            |       |  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:       222520 ave      222520 max      222520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222520
Ave neighs/atom = 111.26
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.56074255111, Press = -2.96602753519911
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10458.12      -10458.12      -10525.361     -10525.361      260.22885      260.22885      28001.702      28001.702      1294.3905      1294.3905    
     45000  -10454.974     -10454.974     -10525.084     -10525.084      271.33429      271.33429      28066.396      28066.396     -2035.4035     -2035.4035    
Loop time of 44.4903 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.942 ns/day, 12.358 hours/ns, 22.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    | 44.407     | 44.407     | 44.407     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015206   | 0.015206   | 0.015206   |   0.0 |  0.03
Output  | 2.7813e-05 | 2.7813e-05 | 2.7813e-05 |   0.0 |  0.00
Modify  | 0.062067   | 0.062067   | 0.062067   |   0.0 |  0.14
Other   |            | 0.005808   |            |       |  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:       222616 ave      222616 max      222616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222616
Ave neighs/atom = 111.308
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.51919765605, Press = -0.177902462274803
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10454.974     -10454.974     -10525.084     -10525.084      271.33429      271.33429      28066.396      28066.396     -2035.4035     -2035.4035    
     46000  -10457.666     -10457.666     -10528.063     -10528.063      272.44401      272.44401      27992.254      27992.254      1550.2856      1550.2856    
Loop time of 44.5031 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.941 ns/day, 12.362 hours/ns, 22.470 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    | 44.42      | 44.42      | 44.42      |   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.1411e-05 | 2.1411e-05 | 2.1411e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.14
Other   |            | 0.005681   |            |       |  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:       222454 ave      222454 max      222454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222454
Ave neighs/atom = 111.227
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451990161047, Press = -1.69473651636438
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10457.666     -10457.666     -10528.063     -10528.063      272.44401      272.44401      27992.254      27992.254      1550.2856      1550.2856    
     47000  -10454.279     -10454.279     -10524.963     -10524.963      273.55487      273.55487      28051.221      28051.221     -1201.3624     -1201.3624    
Loop time of 44.3749 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.947 ns/day, 12.326 hours/ns, 22.535 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    | 44.292     | 44.292     | 44.292     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015157   | 0.015157   | 0.015157   |   0.0 |  0.03
Output  | 3.0407e-05 | 3.0407e-05 | 3.0407e-05 |   0.0 |  0.00
Modify  | 0.062182   | 0.062182   | 0.062182   |   0.0 |  0.14
Other   |            | 0.00599    |            |       |  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:       222638 ave      222638 max      222638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222638
Ave neighs/atom = 111.319
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454297997942, Press = -1.45429473537976
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10454.279     -10454.279     -10524.963     -10524.963      273.55487      273.55487      28051.221      28051.221     -1201.3624     -1201.3624    
     48000  -10456.807     -10456.807     -10526.003     -10526.003      267.79224      267.79224      28016.465      28016.465      493.65747      493.65747    
Loop time of 44.4894 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.942 ns/day, 12.358 hours/ns, 22.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    | 44.405     | 44.405     | 44.405     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015295   | 0.015295   | 0.015295   |   0.0 |  0.03
Output  | 2.9886e-05 | 2.9886e-05 | 2.9886e-05 |   0.0 |  0.00
Modify  | 0.062366   | 0.062366   | 0.062366   |   0.0 |  0.14
Other   |            | 0.006247   |            |       |  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:       222408 ave      222408 max      222408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222408
Ave neighs/atom = 111.204
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460017498418, Press = -1.44952473557013
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10456.807     -10456.807     -10526.003     -10526.003      267.79224      267.79224      28016.465      28016.465      493.65747      493.65747    
     49000  -10458.521     -10458.521     -10525.581     -10525.581      259.52683      259.52683      28019.595      28019.595      397.52664      397.52664    
Loop time of 44.3965 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.946 ns/day, 12.332 hours/ns, 22.524 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    | 44.313     | 44.313     | 44.313     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015279   | 0.015279   | 0.015279   |   0.0 |  0.03
Output  | 2.8063e-05 | 2.8063e-05 | 2.8063e-05 |   0.0 |  0.00
Modify  | 0.062232   | 0.062232   | 0.062232   |   0.0 |  0.14
Other   |            | 0.006074   |            |       |  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:       222572 ave      222572 max      222572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222572
Ave neighs/atom = 111.286
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454251354383, Press = -1.55954014749534
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10458.521     -10458.521     -10525.581     -10525.581      259.52683      259.52683      28019.595      28019.595      397.52664      397.52664    
     50000  -10455.571     -10455.571     -10524.968     -10524.968      268.57075      268.57075      28027.845      28027.845      160.58651      160.58651    
Loop time of 44.5146 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.941 ns/day, 12.365 hours/ns, 22.465 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    | 44.431     | 44.431     | 44.431     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015153   | 0.015153   | 0.015153   |   0.0 |  0.03
Output  | 2.1791e-05 | 2.1791e-05 | 2.1791e-05 |   0.0 |  0.00
Modify  | 0.062158   | 0.062158   | 0.062158   |   0.0 |  0.14
Other   |            | 0.005828   |            |       |  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:       222560 ave      222560 max      222560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222560
Ave neighs/atom = 111.28
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.385170614526, Press = -1.18093922420904
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10455.571     -10455.571     -10524.968     -10524.968      268.57075      268.57075      28027.845      28027.845      160.58651      160.58651    
     51000  -10456.79      -10456.79      -10525.884     -10525.884      267.40112      267.40112      28020.636      28020.636      318.77705      318.77705    
Loop time of 44.3143 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.950 ns/day, 12.310 hours/ns, 22.566 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    | 44.231     | 44.231     | 44.231     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015305   | 0.015305   | 0.015305   |   0.0 |  0.03
Output  | 2.9115e-05 | 2.9115e-05 | 2.9115e-05 |   0.0 |  0.00
Modify  | 0.062205   | 0.062205   | 0.062205   |   0.0 |  0.14
Other   |            | 0.00609    |            |       |  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:       222498 ave      222498 max      222498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222498
Ave neighs/atom = 111.249
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37747799968, Press = -1.61298681977647
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10456.79      -10456.79      -10525.884     -10525.884      267.40112      267.40112      28020.636      28020.636      318.77705      318.77705    
     52000  -10454.726     -10454.726     -10524.642     -10524.642      270.58308      270.58308      28047.296      28047.296     -1111.4561     -1111.4561    
Loop time of 44.3299 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.949 ns/day, 12.314 hours/ns, 22.558 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    | 44.247     | 44.247     | 44.247     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015123   | 0.015123   | 0.015123   |   0.0 |  0.03
Output  | 5.1938e-05 | 5.1938e-05 | 5.1938e-05 |   0.0 |  0.00
Modify  | 0.062176   | 0.062176   | 0.062176   |   0.0 |  0.14
Other   |            | 0.005853   |            |       |  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:       222580 ave      222580 max      222580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222580
Ave neighs/atom = 111.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.312412892241, Press = -1.2025122735857
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10454.726     -10454.726     -10524.642     -10524.642      270.58308      270.58308      28047.296      28047.296     -1111.4561     -1111.4561    
     53000  -10454.106     -10454.106     -10525.963     -10525.963      278.09383      278.09383      28003.666      28003.666      1306.0119      1306.0119    
Loop time of 44.3846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.947 ns/day, 12.329 hours/ns, 22.530 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    | 44.302     | 44.302     | 44.302     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015108   | 0.015108   | 0.015108   |   0.0 |  0.03
Output  | 2.7562e-05 | 2.7562e-05 | 2.7562e-05 |   0.0 |  0.00
Modify  | 0.062111   | 0.062111   | 0.062111   |   0.0 |  0.14
Other   |            | 0.005828   |            |       |  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:       222402 ave      222402 max      222402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222402
Ave neighs/atom = 111.201
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.307595894942, Press = -1.4268705589023
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10454.106     -10454.106     -10525.963     -10525.963      278.09383      278.09383      28003.666      28003.666      1306.0119      1306.0119    
     54000  -10454.644     -10454.644     -10526.634     -10526.634      278.60849      278.60849      28059.864      28059.864     -1841.6853     -1841.6853    
Loop time of 44.4415 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.944 ns/day, 12.345 hours/ns, 22.501 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    | 44.358     | 44.358     | 44.358     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015188   | 0.015188   | 0.015188   |   0.0 |  0.03
Output  | 2.139e-05  | 2.139e-05  | 2.139e-05  |   0.0 |  0.00
Modify  | 0.062292   | 0.062292   | 0.062292   |   0.0 |  0.14
Other   |            | 0.006011   |            |       |  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:       222694 ave      222694 max      222694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222694
Ave neighs/atom = 111.347
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.299430009868, Press = -1.54476737586096
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10454.644     -10454.644     -10526.634     -10526.634      278.60849      278.60849      28059.864      28059.864     -1841.6853     -1841.6853    
     55000  -10455.421     -10455.421     -10525.258     -10525.258      270.27727      270.27727      27992.363      27992.363      1865.0218      1865.0218    
Loop time of 44.4574 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.943 ns/day, 12.349 hours/ns, 22.493 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    | 44.374     | 44.374     | 44.374     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015175   | 0.015175   | 0.015175   |   0.0 |  0.03
Output  | 2.8984e-05 | 2.8984e-05 | 2.8984e-05 |   0.0 |  0.00
Modify  | 0.062231   | 0.062231   | 0.062231   |   0.0 |  0.14
Other   |            | 0.006033   |            |       |  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:       222584 ave      222584 max      222584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222584
Ave neighs/atom = 111.292
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.309411785538, Press = -0.347725958828401
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10455.421     -10455.421     -10525.258     -10525.258      270.27727      270.27727      27992.363      27992.363      1865.0218      1865.0218    
     56000  -10456.8       -10456.8       -10526.368     -10526.368      269.23499      269.23499      28048.023      28048.023     -1246.6762     -1246.6762    
Loop time of 44.5056 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.941 ns/day, 12.363 hours/ns, 22.469 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    | 44.421     | 44.421     | 44.421     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015378   | 0.015378   | 0.015378   |   0.0 |  0.03
Output  | 2.9646e-05 | 2.9646e-05 | 2.9646e-05 |   0.0 |  0.00
Modify  | 0.062305   | 0.062305   | 0.062305   |   0.0 |  0.14
Other   |            | 0.006412   |            |       |  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:       222610 ave      222610 max      222610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222610
Ave neighs/atom = 111.305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.255756707582, Press = -2.66894433351305
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10456.8       -10456.8       -10526.368     -10526.368      269.23499      269.23499      28048.023      28048.023     -1246.6762     -1246.6762    
     57000  -10456.963     -10456.963     -10529.024     -10529.024      278.88353      278.88353      28025.72       28025.72      -244.28897     -244.28897    
Loop time of 44.4578 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.943 ns/day, 12.349 hours/ns, 22.493 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    | 44.375     | 44.375     | 44.375     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015031   | 0.015031   | 0.015031   |   0.0 |  0.03
Output  | 2.6951e-05 | 2.6951e-05 | 2.6951e-05 |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.14
Other   |            | 0.005762   |            |       |  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:       222584 ave      222584 max      222584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222584
Ave neighs/atom = 111.292
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
28027.4682372263

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0