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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.8809778466820717*${_u_distance}
variable latticeconst_converted equal 2.8809778466820717*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097784668207
Lattice spacing in x,y,z = 2.8809778 2.8809778 2.8809778
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.809778 28.809778 28.809778)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.809778 28.809778 28.809778)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Cr__MO_134550636109_001
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8129.4205     -8129.4205     -8200          -8200           273.15         273.15         23912.212      23912.212      3152.6568      3152.6568    
      1000  -8054.1138     -8054.1138     -8127.488      -8127.488       283.96587      283.96587      24077.461      24077.461     -222.37665     -222.37665    
Loop time of 94.8601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.350 hours/ns, 10.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.384     | 94.384     | 94.384     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076459   | 0.076459   | 0.076459   |   0.0 |  0.08
Output  | 0.00021615 | 0.00021615 | 0.00021615 |   0.0 |  0.00
Modify  | 0.34422    | 0.34422    | 0.34422    |   0.0 |  0.36
Other   |            | 0.05558    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8054.1138     -8054.1138     -8127.488      -8127.488       283.96587      283.96587      24077.461      24077.461     -222.37665     -222.37665    
      2000  -8054.8351     -8054.8351     -8125.1612     -8125.1612      272.16916      272.16916      24099.659      24099.659     -2231.6268     -2231.6268    
Loop time of 96.2628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.740 hours/ns, 10.388 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.799     | 95.799     | 95.799     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07311    | 0.07311    | 0.07311    |   0.0 |  0.08
Output  | 0.00020679 | 0.00020679 | 0.00020679 |   0.0 |  0.00
Modify  | 0.33617    | 0.33617    | 0.33617    |   0.0 |  0.35
Other   |            | 0.05456    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116140 ave      116140 max      116140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116140
Ave neighs/atom = 58.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8054.8351     -8054.8351     -8125.1612     -8125.1612      272.16916      272.16916      24099.659      24099.659     -2231.6268     -2231.6268    
      3000  -8055.786      -8055.786      -8125.3738     -8125.3738      269.31214      269.31214      24058.144      24058.144      1072.2876      1072.2876    
Loop time of 96.3626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.767 hours/ns, 10.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.9       | 95.9       | 95.9       |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071659   | 0.071659   | 0.071659   |   0.0 |  0.07
Output  | 0.00020764 | 0.00020764 | 0.00020764 |   0.0 |  0.00
Modify  | 0.33494    | 0.33494    | 0.33494    |   0.0 |  0.35
Other   |            | 0.05566    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8055.786      -8055.786      -8125.3738     -8125.3738      269.31214      269.31214      24058.144      24058.144      1072.2876      1072.2876    
      4000  -8053.7675     -8053.7675     -8125.7813     -8125.7813      278.70109      278.70109      24059.377      24059.377      1171.1506      1171.1506    
Loop time of 96.4007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.778 hours/ns, 10.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.938     | 95.938     | 95.938     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071575   | 0.071575   | 0.071575   |   0.0 |  0.07
Output  | 0.00020851 | 0.00020851 | 0.00020851 |   0.0 |  0.00
Modify  | 0.33552    | 0.33552    | 0.33552    |   0.0 |  0.35
Other   |            | 0.05554    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116168 ave      116168 max      116168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116168
Ave neighs/atom = 58.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8053.7675     -8053.7675     -8125.7813     -8125.7813      278.70109      278.70109      24059.377      24059.377      1171.1506      1171.1506    
      5000  -8056.2286     -8056.2286     -8127.5631     -8127.5631      276.07204      276.07204      24117.894      24117.894     -3838.1259     -3838.1259    
Loop time of 96.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.809 hours/ns, 10.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.047     | 96.047     | 96.047     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072206   | 0.072206   | 0.072206   |   0.0 |  0.07
Output  | 0.00019723 | 0.00019723 | 0.00019723 |   0.0 |  0.00
Modify  | 0.33861    | 0.33861    | 0.33861    |   0.0 |  0.35
Other   |            | 0.0548     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116150 ave      116150 max      116150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.980258339232, Press = 117.69216519675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8056.2286     -8056.2286     -8127.5631     -8127.5631      276.07204      276.07204      24117.894      24117.894     -3838.1259     -3838.1259    
      6000  -8053.7902     -8053.7902     -8126.3246     -8126.3246      280.71572      280.71572      24069.948      24069.948      214.32918      214.32918    
Loop time of 96.2673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.741 hours/ns, 10.388 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.782     | 95.782     | 95.782     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073552   | 0.073552   | 0.073552   |   0.0 |  0.08
Output  | 0.00016861 | 0.00016861 | 0.00016861 |   0.0 |  0.00
Modify  | 0.35673    | 0.35673    | 0.35673    |   0.0 |  0.37
Other   |            | 0.05461    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116122 ave      116122 max      116122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116122
Ave neighs/atom = 58.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.588163128201, Press = 140.204719432706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8053.7902     -8053.7902     -8126.3246     -8126.3246      280.71572      280.71572      24069.948      24069.948      214.32918      214.32918    
      7000  -8058.0137     -8058.0137     -8127.4885     -8127.4885      268.87465      268.87465      24047.186      24047.186      1528.7615      1528.7615    
Loop time of 113.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.522 hours/ns, 8.812 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.89     | 112.89     | 112.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082963   | 0.082963   | 0.082963   |   0.0 |  0.07
Output  | 0.00020396 | 0.00020396 | 0.00020396 |   0.0 |  0.00
Modify  | 0.4429     | 0.4429     | 0.4429     |   0.0 |  0.39
Other   |            | 0.06244    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116156 ave      116156 max      116156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116156
Ave neighs/atom = 58.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.015827746744, Press = 22.5749190943389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8058.0137     -8058.0137     -8127.4885     -8127.4885      268.87465      268.87465      24047.186      24047.186      1528.7615      1528.7615    
      8000  -8055.2389     -8055.2389     -8126.7787     -8126.7787      276.86653      276.86653      24078.992      24078.992     -527.21621     -527.21621    
Loop time of 113.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.504 hours/ns, 8.817 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    | 112.82     | 112.82     | 112.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083742   | 0.083742   | 0.083742   |   0.0 |  0.07
Output  | 0.00021898 | 0.00021898 | 0.00021898 |   0.0 |  0.00
Modify  | 0.44429    | 0.44429    | 0.44429    |   0.0 |  0.39
Other   |            | 0.0622     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116164 ave      116164 max      116164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116164
Ave neighs/atom = 58.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.666182776301, Press = 6.41767469529802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8055.2389     -8055.2389     -8126.7787     -8126.7787      276.86653      276.86653      24078.992      24078.992     -527.21621     -527.21621    
      9000  -8054.4716     -8054.4716     -8126.4151     -8126.4151      278.42908      278.42908      24078.894      24078.894     -473.90553     -473.90553    
Loop time of 113.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.615 hours/ns, 8.786 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.22     | 113.22     | 113.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084684   | 0.084684   | 0.084684   |   0.0 |  0.07
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.44855    | 0.44855    | 0.44855    |   0.0 |  0.39
Other   |            | 0.06272    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.008440045673, Press = 17.3039138055536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8054.4716     -8054.4716     -8126.4151     -8126.4151      278.42908      278.42908      24078.894      24078.894     -473.90553     -473.90553    
     10000  -8053.0528     -8053.0528     -8124.7304     -8124.7304      277.39975      277.39975      24046.49       24046.49       2102.7879      2102.7879    
Loop time of 113.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.503 hours/ns, 8.817 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.82     | 112.82     | 112.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082933   | 0.082933   | 0.082933   |   0.0 |  0.07
Output  | 0.00027185 | 0.00027185 | 0.00027185 |   0.0 |  0.00
Modify  | 0.44591    | 0.44591    | 0.44591    |   0.0 |  0.39
Other   |            | 0.0628     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116186 ave      116186 max      116186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116186
Ave neighs/atom = 58.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416037656236, Press = 13.7675539605495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8053.0528     -8053.0528     -8124.7304     -8124.7304      277.39975      277.39975      24046.49       24046.49       2102.7879      2102.7879    
     11000  -8054.4291     -8054.4291     -8124.8229     -8124.8229      272.43139      272.43139      24070.722      24070.722      175.83142      175.83142    
Loop time of 110.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.781 ns/day, 30.731 hours/ns, 9.039 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.06     | 110.06     | 110.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081441   | 0.081441   | 0.081441   |   0.0 |  0.07
Output  | 0.00016946 | 0.00016946 | 0.00016946 |   0.0 |  0.00
Modify  | 0.43046    | 0.43046    | 0.43046    |   0.0 |  0.39
Other   |            | 0.06137    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116170 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.478211161743, Press = -4.75167601068752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8054.4291     -8054.4291     -8124.8229     -8124.8229      272.43139      272.43139      24070.722      24070.722      175.83142      175.83142    
     12000  -8055.0163     -8055.0163     -8126.0753     -8126.0753      275.00547      275.00547      24112.936      24112.936     -3229.4507     -3229.4507    
Loop time of 113.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.548 hours/ns, 8.805 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.98     | 112.98     | 112.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084455   | 0.084455   | 0.084455   |   0.0 |  0.07
Output  | 0.00017078 | 0.00017078 | 0.00017078 |   0.0 |  0.00
Modify  | 0.44778    | 0.44778    | 0.44778    |   0.0 |  0.39
Other   |            | 0.06258    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865249431293, Press = 8.74052637049293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8055.0163     -8055.0163     -8126.0753     -8126.0753      275.00547      275.00547      24112.936      24112.936     -3229.4507     -3229.4507    
     13000  -8052.4878     -8052.4878     -8125.4675     -8125.4675      282.4389       282.4389       24056.277      24056.277      1376.3549      1376.3549    
Loop time of 113.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.538 hours/ns, 8.808 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.94     | 112.94     | 112.94     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083224   | 0.083224   | 0.083224   |   0.0 |  0.07
Output  | 0.00020966 | 0.00020966 | 0.00020966 |   0.0 |  0.00
Modify  | 0.44643    | 0.44643    | 0.44643    |   0.0 |  0.39
Other   |            | 0.06246    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116108 ave      116108 max      116108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116108
Ave neighs/atom = 58.054
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872097957485, Press = 13.9417989181772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8052.4878     -8052.4878     -8125.4675     -8125.4675      282.4389       282.4389       24056.277      24056.277      1376.3549      1376.3549    
     14000  -8054.1076     -8054.1076     -8122.5796     -8122.5796      264.99372      264.99372      24059.213      24059.213      1317.9215      1317.9215    
Loop time of 107.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.837 hours/ns, 9.310 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.86     | 106.86     | 106.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079067   | 0.079067   | 0.079067   |   0.0 |  0.07
Output  | 0.00016629 | 0.00016629 | 0.00016629 |   0.0 |  0.00
Modify  | 0.4131     | 0.4131     | 0.4131     |   0.0 |  0.38
Other   |            | 0.05919    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.901898695051, Press = 2.11945652260326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8054.1076     -8054.1076     -8122.5796     -8122.5796      264.99372      264.99372      24059.213      24059.213      1317.9215      1317.9215    
     15000  -8056.6505     -8056.6505     -8127.8835     -8127.8835      275.67892      275.67892      24091.538      24091.538     -1709.3316     -1709.3316    
Loop time of 96.5368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.816 hours/ns, 10.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.052     | 96.052     | 96.052     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072769   | 0.072769   | 0.072769   |   0.0 |  0.08
Output  | 0.00016985 | 0.00016985 | 0.00016985 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.37
Other   |            | 0.05491    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116198 ave      116198 max      116198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116198
Ave neighs/atom = 58.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.614044819295, Press = 3.30992730067044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8056.6505     -8056.6505     -8127.8835     -8127.8835      275.67892      275.67892      24091.538      24091.538     -1709.3316     -1709.3316    
     16000  -8056.4752     -8056.4752     -8127.669      -8127.669       275.52749      275.52749      24077.128      24077.128     -576.74977     -576.74977    
Loop time of 96.5393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.816 hours/ns, 10.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.054     | 96.054     | 96.054     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073133   | 0.073133   | 0.073133   |   0.0 |  0.08
Output  | 0.00016978 | 0.00016978 | 0.00016978 |   0.0 |  0.00
Modify  | 0.35651    | 0.35651    | 0.35651    |   0.0 |  0.37
Other   |            | 0.05501    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116146 ave      116146 max      116146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116146
Ave neighs/atom = 58.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516588864966, Press = 8.53431008616184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8056.4752     -8056.4752     -8127.669      -8127.669       275.52749      275.52749      24077.128      24077.128     -576.74977     -576.74977    
     17000  -8052.0007     -8052.0007     -8123.902      -8123.902       278.26572      278.26572      24026.782      24026.782      3693.329       3693.329     
Loop time of 96.5193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.811 hours/ns, 10.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.035     | 96.035     | 96.035     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072961   | 0.072961   | 0.072961   |   0.0 |  0.08
Output  | 0.00016987 | 0.00016987 | 0.00016987 |   0.0 |  0.00
Modify  | 0.35681    | 0.35681    | 0.35681    |   0.0 |  0.37
Other   |            | 0.05483    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116124 ave      116124 max      116124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116124
Ave neighs/atom = 58.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.644477925435, Press = 3.94244151865635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8052.0007     -8052.0007     -8123.902      -8123.902       278.26572      278.26572      24026.782      24026.782      3693.329       3693.329     
     18000  -8056.6015     -8056.6015     -8126.2095     -8126.2095      269.39014      269.39014      24094.35       24094.35      -1727.4755     -1727.4755    
Loop time of 96.4429 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.790 hours/ns, 10.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.958     | 95.958     | 95.958     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073442   | 0.073442   | 0.073442   |   0.0 |  0.08
Output  | 0.0001681  | 0.0001681  | 0.0001681  |   0.0 |  0.00
Modify  | 0.35607    | 0.35607    | 0.35607    |   0.0 |  0.37
Other   |            | 0.05535    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.621876044193, Press = -2.43112064141126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8056.6015     -8056.6015     -8126.2095     -8126.2095      269.39014      269.39014      24094.35       24094.35      -1727.4755     -1727.4755    
     19000  -8054.4408     -8054.4408     -8124.7521     -8124.7521      272.11197      272.11197      24090.306      24090.306     -1163.4395     -1163.4395    
Loop time of 96.4096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.925     | 95.925     | 95.925     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073079   | 0.073079   | 0.073079   |   0.0 |  0.08
Output  | 0.00016733 | 0.00016733 | 0.00016733 |   0.0 |  0.00
Modify  | 0.35646    | 0.35646    | 0.35646    |   0.0 |  0.37
Other   |            | 0.05472    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740088607847, Press = 6.19261563766204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8054.4408     -8054.4408     -8124.7521     -8124.7521      272.11197      272.11197      24090.306      24090.306     -1163.4395     -1163.4395    
     20000  -8057.0002     -8057.0002     -8128.2765     -8128.2765      275.84681      275.84681      24056.434      24056.434      959.38973      959.38973    
Loop time of 96.5643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.823 hours/ns, 10.356 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.08      | 96.08      | 96.08      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072932   | 0.072932   | 0.072932   |   0.0 |  0.08
Output  | 0.00020395 | 0.00020395 | 0.00020395 |   0.0 |  0.00
Modify  | 0.35639    | 0.35639    | 0.35639    |   0.0 |  0.37
Other   |            | 0.05509    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116168 ave      116168 max      116168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116168
Ave neighs/atom = 58.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.783487463308, Press = 5.07988992873033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8057.0002     -8057.0002     -8128.2765     -8128.2765      275.84681      275.84681      24056.434      24056.434      959.38973      959.38973    
     21000  -8053.2583     -8053.2583     -8125.7572     -8125.7572      280.57851      280.57851      24071.127      24071.127      196.81638      196.81638    
Loop time of 96.7403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.872 hours/ns, 10.337 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.254     | 96.254     | 96.254     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073023   | 0.073023   | 0.073023   |   0.0 |  0.08
Output  | 0.00016974 | 0.00016974 | 0.00016974 |   0.0 |  0.00
Modify  | 0.35711    | 0.35711    | 0.35711    |   0.0 |  0.37
Other   |            | 0.05551    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116162 ave      116162 max      116162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116162
Ave neighs/atom = 58.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.76871526517, Press = 0.876464362810166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8053.2583     -8053.2583     -8125.7572     -8125.7572      280.57851      280.57851      24071.127      24071.127      196.81638      196.81638    
     22000  -8055.1035     -8055.1035     -8125.9156     -8125.9156      274.05017      274.05017      24098.152      24098.152     -2049.0975     -2049.0975    
Loop time of 97.1443 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.889 ns/day, 26.985 hours/ns, 10.294 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.656     | 96.656     | 96.656     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073199   | 0.073199   | 0.073199   |   0.0 |  0.08
Output  | 0.00016914 | 0.00016914 | 0.00016914 |   0.0 |  0.00
Modify  | 0.35971    | 0.35971    | 0.35971    |   0.0 |  0.37
Other   |            | 0.05534    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116158 ave      116158 max      116158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116158
Ave neighs/atom = 58.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.76581108873, Press = 3.05947306563062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8055.1035     -8055.1035     -8125.9156     -8125.9156      274.05017      274.05017      24098.152      24098.152     -2049.0975     -2049.0975    
     23000  -8054.9873     -8054.9873     -8125.6        -8125.6         273.27817      273.27817      24056.439      24056.439      1309.7749      1309.7749    
Loop time of 96.4656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.796 hours/ns, 10.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.981     | 95.981     | 95.981     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072964   | 0.072964   | 0.072964   |   0.0 |  0.08
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.35708    | 0.35708    | 0.35708    |   0.0 |  0.37
Other   |            | 0.05474    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.667505649112, Press = 7.46742515798756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8054.9873     -8054.9873     -8125.6        -8125.6         273.27817      273.27817      24056.439      24056.439      1309.7749      1309.7749    
     24000  -8055.2625     -8055.2625     -8127.8585     -8127.8585      280.95384      280.95384      24027.696      24027.696      3302.5972      3302.5972    
Loop time of 96.5097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.808 hours/ns, 10.362 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.025     | 96.025     | 96.025     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074011   | 0.074011   | 0.074011   |   0.0 |  0.08
Output  | 0.00016795 | 0.00016795 | 0.00016795 |   0.0 |  0.00
Modify  | 0.35562    | 0.35562    | 0.35562    |   0.0 |  0.37
Other   |            | 0.05509    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2948 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.639763967039, Press = 0.288818744854649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8055.2625     -8055.2625     -8127.8585     -8127.8585      280.95384      280.95384      24027.696      24027.696      3302.5972      3302.5972    
     25000  -8056.4338     -8056.4338     -8124.5906     -8124.5906      263.77415      263.77415      24082.165      24082.165     -724.09903     -724.09903    
Loop time of 96.5444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.818 hours/ns, 10.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.059     | 96.059     | 96.059     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07293    | 0.07293    | 0.07293    |   0.0 |  0.08
Output  | 0.0001697  | 0.0001697  | 0.0001697  |   0.0 |  0.00
Modify  | 0.35721    | 0.35721    | 0.35721    |   0.0 |  0.37
Other   |            | 0.05493    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.53695533926, Press = 2.02040487038185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8056.4338     -8056.4338     -8124.5906     -8124.5906      263.77415      263.77415      24082.165      24082.165     -724.09903     -724.09903    
     26000  -8055.667      -8055.667      -8126.8255     -8126.8255      275.39078      275.39078      24080.572      24080.572     -705.29684     -705.29684    
Loop time of 103.029 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.619 hours/ns, 9.706 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.5      | 102.5      | 102.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076738   | 0.076738   | 0.076738   |   0.0 |  0.07
Output  | 0.00016888 | 0.00016888 | 0.00016888 |   0.0 |  0.00
Modify  | 0.38965    | 0.38965    | 0.38965    |   0.0 |  0.38
Other   |            | 0.05791    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116130 ave      116130 max      116130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116130
Ave neighs/atom = 58.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466225432939, Press = 3.29819972849308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8055.667      -8055.667      -8126.8255     -8126.8255      275.39078      275.39078      24080.572      24080.572     -705.29684     -705.29684    
     27000  -8053.9083     -8053.9083     -8125.5993     -8125.5993      277.45167      277.45167      24062.492      24062.492      881.18316      881.18316    
Loop time of 113.814 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.615 hours/ns, 8.786 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.22     | 113.22     | 113.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083431   | 0.083431   | 0.083431   |   0.0 |  0.07
Output  | 0.00023518 | 0.00023518 | 0.00023518 |   0.0 |  0.00
Modify  | 0.44726    | 0.44726    | 0.44726    |   0.0 |  0.39
Other   |            | 0.06228    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116138 ave      116138 max      116138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116138
Ave neighs/atom = 58.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.342184637938, Press = 3.0846027215987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8053.9083     -8053.9083     -8125.5993     -8125.5993      277.45167      277.45167      24062.492      24062.492      881.18316      881.18316    
     28000  -8056.1803     -8056.1803     -8126.3719     -8126.3719      271.64901      271.64901      24063.467      24063.467      651.79909      651.79909    
Loop time of 113.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.588 hours/ns, 8.794 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.12     | 113.12     | 113.12     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083768   | 0.083768   | 0.083768   |   0.0 |  0.07
Output  | 0.00016845 | 0.00016845 | 0.00016845 |   0.0 |  0.00
Modify  | 0.44861    | 0.44861    | 0.44861    |   0.0 |  0.39
Other   |            | 0.06261    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116164 ave      116164 max      116164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116164
Ave neighs/atom = 58.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.333441909609, Press = 0.547798660186197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8056.1803     -8056.1803     -8126.3719     -8126.3719      271.64901      271.64901      24063.467      24063.467      651.79909      651.79909    
     29000  -8054.4129     -8054.4129     -8125.795      -8125.795       276.25593      276.25593      24111.75       24111.75      -2985.7789     -2985.7789    
Loop time of 112.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.338 hours/ns, 8.864 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083641   | 0.083641   | 0.083641   |   0.0 |  0.07
Output  | 0.00020645 | 0.00020645 | 0.00020645 |   0.0 |  0.00
Modify  | 0.44143    | 0.44143    | 0.44143    |   0.0 |  0.39
Other   |            | 0.06282    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116146 ave      116146 max      116146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116146
Ave neighs/atom = 58.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.277195263792, Press = 1.25271027655326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8054.4129     -8054.4129     -8125.795      -8125.795       276.25593      276.25593      24111.75       24111.75      -2985.7789     -2985.7789    
     30000  -8057.6897     -8057.6897     -8125.2873     -8125.2873      261.60985      261.60985      24070.982      24070.982     -0.18601407    -0.18601407   
Loop time of 114.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.682 hours/ns, 8.768 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.46     | 113.46     | 113.46     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084655   | 0.084655   | 0.084655   |   0.0 |  0.07
Output  | 0.00020488 | 0.00020488 | 0.00020488 |   0.0 |  0.00
Modify  | 0.44895    | 0.44895    | 0.44895    |   0.0 |  0.39
Other   |            | 0.0626     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116152 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.202139781489, Press = 5.18212107747065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8057.6897     -8057.6897     -8125.2873     -8125.2873      261.60985      261.60985      24070.982      24070.982     -0.18601407    -0.18601407   
     31000  -8055.0174     -8055.0174     -8125.1069     -8125.1069      271.25371      271.25371      24044.299      24044.299      2231.0661      2231.0661    
Loop time of 112.964 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.379 hours/ns, 8.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.37     | 112.37     | 112.37     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084414   | 0.084414   | 0.084414   |   0.0 |  0.07
Output  | 0.00017134 | 0.00017134 | 0.00017134 |   0.0 |  0.00
Modify  | 0.44513    | 0.44513    | 0.44513    |   0.0 |  0.39
Other   |            | 0.0631     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116144 ave      116144 max      116144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116144
Ave neighs/atom = 58.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.214300543307, Press = 1.79677142338143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8055.0174     -8055.0174     -8125.1069     -8125.1069      271.25371      271.25371      24044.299      24044.299      2231.0661      2231.0661    
     32000  -8055.0099     -8055.0099     -8126.6747     -8126.6747      277.35012      277.35012      24079.437      24079.437     -571.76345     -571.76345    
Loop time of 112.485 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.246 hours/ns, 8.890 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.89     | 111.89     | 111.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083353   | 0.083353   | 0.083353   |   0.0 |  0.07
Output  | 0.00016882 | 0.00016882 | 0.00016882 |   0.0 |  0.00
Modify  | 0.44403    | 0.44403    | 0.44403    |   0.0 |  0.39
Other   |            | 0.06238    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177597100468, Press = 1.08069633094212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8055.0099     -8055.0099     -8126.6747     -8126.6747      277.35012      277.35012      24079.437      24079.437     -571.76345     -571.76345    
     33000  -8058.3041     -8058.3041     -8128.3591     -8128.3591      271.12018      271.12018      24069.876      24069.876     -111.91668     -111.91668    
Loop time of 96.3748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.771 hours/ns, 10.376 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.888     | 95.888     | 95.888     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073514   | 0.073514   | 0.073514   |   0.0 |  0.08
Output  | 0.00016968 | 0.00016968 | 0.00016968 |   0.0 |  0.00
Modify  | 0.35823    | 0.35823    | 0.35823    |   0.0 |  0.37
Other   |            | 0.05502    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116112 ave      116112 max      116112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116112
Ave neighs/atom = 58.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.209444133665, Press = 2.2628579112844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8058.3041     -8058.3041     -8128.3591     -8128.3591      271.12018      271.12018      24069.876      24069.876     -111.91668     -111.91668    
     34000  -8054.3658     -8054.3658     -8125.5242     -8125.5242      275.3904       275.3904       24066.281      24066.281      620.96027      620.96027    
Loop time of 96.6586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.850 hours/ns, 10.346 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.171     | 96.171     | 96.171     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073628   | 0.073628   | 0.073628   |   0.0 |  0.08
Output  | 0.00016766 | 0.00016766 | 0.00016766 |   0.0 |  0.00
Modify  | 0.35795    | 0.35795    | 0.35795    |   0.0 |  0.37
Other   |            | 0.05567    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116100 ave      116100 max      116100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116100
Ave neighs/atom = 58.05
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.16957001388, Press = 1.89939969987812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8054.3658     -8054.3658     -8125.5242     -8125.5242      275.3904       275.3904       24066.281      24066.281      620.96027      620.96027    
     35000  -8053.2587     -8053.2587     -8124.9097     -8124.9097      277.29662      277.29662      24076.798      24076.798     -147.75533     -147.75533    
Loop time of 108.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.796 ns/day, 30.153 hours/ns, 9.212 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.99     | 107.99     | 107.99     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08122    | 0.08122    | 0.08122    |   0.0 |  0.07
Output  | 0.00017068 | 0.00017068 | 0.00017068 |   0.0 |  0.00
Modify  | 0.42347    | 0.42347    | 0.42347    |   0.0 |  0.39
Other   |            | 0.0608     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116134 ave      116134 max      116134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116134
Ave neighs/atom = 58.067
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.265948177561, Press = 1.10562077394796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8053.2587     -8053.2587     -8124.9097     -8124.9097      277.29662      277.29662      24076.798      24076.798     -147.75533     -147.75533    
     36000  -8054.6742     -8054.6742     -8125.7987     -8125.7987      275.25924      275.25924      24085.424      24085.424     -1059.8431     -1059.8431    
Loop time of 96.8777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.910 hours/ns, 10.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.392     | 96.392     | 96.392     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073261   | 0.073261   | 0.073261   |   0.0 |  0.08
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.35719    | 0.35719    | 0.35719    |   0.0 |  0.37
Other   |            | 0.0556     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.287010379103, Press = 1.39913298189115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8054.6742     -8054.6742     -8125.7987     -8125.7987      275.25924      275.25924      24085.424      24085.424     -1059.8431     -1059.8431    
     37000  -8053.2337     -8053.2337     -8125.5568     -8125.5568      279.89803      279.89803      24073.544      24073.544      36.654838      36.654838    
Loop time of 96.4077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.921     | 95.921     | 95.921     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073286   | 0.073286   | 0.073286   |   0.0 |  0.08
Output  | 0.00017038 | 0.00017038 | 0.00017038 |   0.0 |  0.00
Modify  | 0.35821    | 0.35821    | 0.35821    |   0.0 |  0.37
Other   |            | 0.05475    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116146 ave      116146 max      116146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116146
Ave neighs/atom = 58.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361585678043, Press = 2.82439662099559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8053.2337     -8053.2337     -8125.5568     -8125.5568      279.89803      279.89803      24073.544      24073.544      36.654838      36.654838    
     38000  -8052.7447     -8052.7447     -8122.8445     -8122.8445      271.29371      271.29371      24044.963      24044.963      2443.3985      2443.3985    
Loop time of 99.5538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.654 hours/ns, 10.045 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.05      | 99.05      | 99.05      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075348   | 0.075348   | 0.075348   |   0.0 |  0.08
Output  | 0.00016802 | 0.00016802 | 0.00016802 |   0.0 |  0.00
Modify  | 0.37248    | 0.37248    | 0.37248    |   0.0 |  0.37
Other   |            | 0.05607    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116162 ave      116162 max      116162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116162
Ave neighs/atom = 58.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.350749699911, Press = 1.18703285685231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8052.7447     -8052.7447     -8122.8445     -8122.8445      271.29371      271.29371      24044.963      24044.963      2443.3985      2443.3985    
     39000  -8056.121      -8056.121      -8126.1169     -8126.1169      270.89141      270.89141      24090.084      24090.084     -1357.2324     -1357.2324    
Loop time of 113.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.568 hours/ns, 8.799 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    | 113.05     | 113.05     | 113.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084357   | 0.084357   | 0.084357   |   0.0 |  0.07
Output  | 0.00021572 | 0.00021572 | 0.00021572 |   0.0 |  0.00
Modify  | 0.44621    | 0.44621    | 0.44621    |   0.0 |  0.39
Other   |            | 0.06261    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.312743665408, Press = -0.513888133508932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8056.121      -8056.121      -8126.1169     -8126.1169      270.89141      270.89141      24090.084      24090.084     -1357.2324     -1357.2324    
     40000  -8055.3825     -8055.3825     -8124.4374     -8124.4374      267.24955      267.24955      24105.679      24105.679     -2372.827      -2372.827     
Loop time of 113.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.525 hours/ns, 8.811 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.89     | 112.89     | 112.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084432   | 0.084432   | 0.084432   |   0.0 |  0.07
Output  | 0.00024767 | 0.00024767 | 0.00024767 |   0.0 |  0.00
Modify  | 0.44715    | 0.44715    | 0.44715    |   0.0 |  0.39
Other   |            | 0.06323    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116164 ave      116164 max      116164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116164
Ave neighs/atom = 58.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.309951618853, Press = 3.45261610581128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8055.3825     -8055.3825     -8124.4374     -8124.4374      267.24955      267.24955      24105.679      24105.679     -2372.827      -2372.827     
     41000  -8054.6264     -8054.6264     -8125.5029     -8125.5029      274.29934      274.29934      24053.705      24053.705      1575.2489      1575.2489    
Loop time of 113.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.546 hours/ns, 8.805 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.97     | 112.97     | 112.97     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083598   | 0.083598   | 0.083598   |   0.0 |  0.07
Output  | 0.0002143  | 0.0002143  | 0.0002143  |   0.0 |  0.00
Modify  | 0.44624    | 0.44624    | 0.44624    |   0.0 |  0.39
Other   |            | 0.06377    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116140 ave      116140 max      116140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116140
Ave neighs/atom = 58.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.330122589732, Press = 1.80764491272817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8054.6264     -8054.6264     -8125.5029     -8125.5029      274.29934      274.29934      24053.705      24053.705      1575.2489      1575.2489    
     42000  -8055.4704     -8055.4704     -8128.222      -8128.222       281.5565       281.5565       24073.858      24073.858     -322.12375     -322.12375    
Loop time of 113.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.544 hours/ns, 8.806 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.97     | 112.97     | 112.97     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083924   | 0.083924   | 0.083924   |   0.0 |  0.07
Output  | 0.00021505 | 0.00021505 | 0.00021505 |   0.0 |  0.00
Modify  | 0.4441     | 0.4441     | 0.4441     |   0.0 |  0.39
Other   |            | 0.06306    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116158 ave      116158 max      116158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116158
Ave neighs/atom = 58.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.285562507317, Press = 0.599583024381038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8055.4704     -8055.4704     -8128.222      -8128.222       281.5565       281.5565       24073.858      24073.858     -322.12375     -322.12375    
     43000  -8054.564      -8054.564      -8125.3934     -8125.3934      274.11733      274.11733      24087.559      24087.559     -1148.4713     -1148.4713    
Loop time of 113.604 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.557 hours/ns, 8.802 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    | 113.01     | 113.01     | 113.01     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083871   | 0.083871   | 0.083871   |   0.0 |  0.07
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.44656    | 0.44656    | 0.44656    |   0.0 |  0.39
Other   |            | 0.06334    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116150 ave      116150 max      116150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.246615960179, Press = 1.29399632434569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8054.564      -8054.564      -8125.3934     -8125.3934      274.11733      274.11733      24087.559      24087.559     -1148.4713     -1148.4713    
     44000  -8055.217      -8055.217      -8125.3233     -8125.3233      271.31831      271.31831      24057.783      24057.783      1086.3686      1086.3686    
Loop time of 113.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.582 hours/ns, 8.795 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.1      | 113.1      | 113.1      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084537   | 0.084537   | 0.084537   |   0.0 |  0.07
Output  | 0.0001987  | 0.0001987  | 0.0001987  |   0.0 |  0.00
Modify  | 0.4467     | 0.4467     | 0.4467     |   0.0 |  0.39
Other   |            | 0.06374    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116146 ave      116146 max      116146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116146
Ave neighs/atom = 58.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.176083039449, Press = 2.31817835483043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8055.217      -8055.217      -8125.3233     -8125.3233      271.31831      271.31831      24057.783      24057.783      1086.3686      1086.3686    
     45000  -8056.9407     -8056.9407     -8125.1166     -8125.1166      263.84749      263.84749      24044.186      24044.186      2239.9407      2239.9407    
Loop time of 113.554 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.543 hours/ns, 8.806 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.96     | 112.96     | 112.96     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085689   | 0.085689   | 0.085689   |   0.0 |  0.08
Output  | 0.00017222 | 0.00017222 | 0.00017222 |   0.0 |  0.00
Modify  | 0.44313    | 0.44313    | 0.44313    |   0.0 |  0.39
Other   |            | 0.06293    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.153796512038, Press = -0.503703792486862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8056.9407     -8056.9407     -8125.1166     -8125.1166      263.84749      263.84749      24044.186      24044.186      2239.9407      2239.9407    
     46000  -8053.1557     -8053.1557     -8124.327      -8124.327       275.44053      275.44053      24114.9        24114.9       -2925.2555     -2925.2555    
Loop time of 113.574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.548 hours/ns, 8.805 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.98     | 112.98     | 112.98     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084154   | 0.084154   | 0.084154   |   0.0 |  0.07
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.44902    | 0.44902    | 0.44902    |   0.0 |  0.40
Other   |            | 0.06314    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116174 ave      116174 max      116174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116174
Ave neighs/atom = 58.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.181026794758, Press = 0.388738075696426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8053.1557     -8053.1557     -8124.327      -8124.327       275.44053      275.44053      24114.9        24114.9       -2925.2555     -2925.2555    
     47000  -8055.2251     -8055.2251     -8126.4445     -8126.4445      275.62649      275.62649      24073.655      24073.655     -70.792654     -70.792654    
Loop time of 107.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.791 hours/ns, 9.324 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.7      | 106.7      | 106.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079407   | 0.079407   | 0.079407   |   0.0 |  0.07
Output  | 0.00019735 | 0.00019735 | 0.00019735 |   0.0 |  0.00
Modify  | 0.41088    | 0.41088    | 0.41088    |   0.0 |  0.38
Other   |            | 0.06066    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116152 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.213366473777, Press = 2.55567428642661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8055.2251     -8055.2251     -8126.4445     -8126.4445      275.62649      275.62649      24073.655      24073.655     -70.792654     -70.792654    
     48000  -8052.7029     -8052.7029     -8124.9846     -8124.9846      279.73776      279.73776      24052.211      24052.211      1810.0539      1810.0539    
Loop time of 99.3182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.588 hours/ns, 10.069 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.814     | 98.814     | 98.814     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075035   | 0.075035   | 0.075035   |   0.0 |  0.08
Output  | 0.00017014 | 0.00017014 | 0.00017014 |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  0.37
Other   |            | 0.05671    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.275480315072, Press = 0.755776717639939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8052.7029     -8052.7029     -8124.9846     -8124.9846      279.73776      279.73776      24052.211      24052.211      1810.0539      1810.0539    
     49000  -8053.2281     -8053.2281     -8124.5239     -8124.5239      275.92214      275.92214      24085.286      24085.286     -753.31016     -753.31016    
Loop time of 113.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.412 hours/ns, 8.843 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.49     | 112.49     | 112.49     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083533   | 0.083533   | 0.083533   |   0.0 |  0.07
Output  | 0.000252   | 0.000252   | 0.000252   |   0.0 |  0.00
Modify  | 0.44678    | 0.44678    | 0.44678    |   0.0 |  0.40
Other   |            | 0.06302    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116168 ave      116168 max      116168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116168
Ave neighs/atom = 58.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.283236288044, Press = 0.585122437592257
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8053.2281     -8053.2281     -8124.5239     -8124.5239      275.92214      275.92214      24085.286      24085.286     -753.31016     -753.31016    
     50000  -8057.5096     -8057.5096     -8126.2554     -8126.2554      266.05329      266.05329      24079.443      24079.443     -614.47295     -614.47295    
Loop time of 113.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.439 hours/ns, 8.835 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.59     | 112.59     | 112.59     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082746   | 0.082746   | 0.082746   |   0.0 |  0.07
Output  | 0.00016922 | 0.00016922 | 0.00016922 |   0.0 |  0.00
Modify  | 0.4462     | 0.4462     | 0.4462     |   0.0 |  0.39
Other   |            | 0.06258    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116150 ave      116150 max      116150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.280479690617, Press = 1.52280436842284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8057.5096     -8057.5096     -8126.2554     -8126.2554      266.05329      266.05329      24079.443      24079.443     -614.47295     -614.47295    
     51000  -8055.2159     -8055.2159     -8125.0681     -8125.0681      270.33519      270.33519      24044.092      24044.092      2343.254       2343.254     
Loop time of 113.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.490 hours/ns, 8.821 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.77     | 112.77     | 112.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082604   | 0.082604   | 0.082604   |   0.0 |  0.07
Output  | 0.00021223 | 0.00021223 | 0.00021223 |   0.0 |  0.00
Modify  | 0.44701    | 0.44701    | 0.44701    |   0.0 |  0.39
Other   |            | 0.06265    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116152 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.263407435753, Press = 1.70398000319135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8055.2159     -8055.2159     -8125.0681     -8125.0681      270.33519      270.33519      24044.092      24044.092      2343.254       2343.254     
     52000  -8055.1603     -8055.1603     -8126.1063     -8126.1063      274.56856      274.56856      24059.095      24059.095      1091.9543      1091.9543    
Loop time of 113.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.453 hours/ns, 8.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.64     | 112.64     | 112.64     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082715   | 0.082715   | 0.082715   |   0.0 |  0.07
Output  | 0.00016939 | 0.00016939 | 0.00016939 |   0.0 |  0.00
Modify  | 0.44705    | 0.44705    | 0.44705    |   0.0 |  0.39
Other   |            | 0.0629     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.203819516937, Press = -0.768227418226886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8055.1603     -8055.1603     -8126.1063     -8126.1063      274.56856      274.56856      24059.095      24059.095      1091.9543      1091.9543    
     53000  -8054.7723     -8054.7723     -8124.4427     -8124.4427      269.63174      269.63174      24106.279      24106.279     -2343.6294     -2343.6294    
Loop time of 113.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.398 hours/ns, 8.847 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.44     | 112.44     | 112.44     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082363   | 0.082363   | 0.082363   |   0.0 |  0.07
Output  | 0.0002634  | 0.0002634  | 0.0002634  |   0.0 |  0.00
Modify  | 0.44568    | 0.44568    | 0.44568    |   0.0 |  0.39
Other   |            | 0.0626     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.171001137565, Press = 1.12355393748584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8054.7723     -8054.7723     -8124.4427     -8124.4427      269.63174      269.63174      24106.279      24106.279     -2343.6294     -2343.6294    
     54000  -8052.4468     -8052.4468     -8123.8796     -8123.8796      276.45205      276.45205      24069.779      24069.779      546.2536       546.2536     
Loop time of 111.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.981 hours/ns, 8.966 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.95     | 110.95     | 110.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082544   | 0.082544   | 0.082544   |   0.0 |  0.07
Output  | 0.0002102  | 0.0002102  | 0.0002102  |   0.0 |  0.00
Modify  | 0.43876    | 0.43876    | 0.43876    |   0.0 |  0.39
Other   |            | 0.06221    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116138 ave      116138 max      116138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116138
Ave neighs/atom = 58.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.15033196544, Press = 1.72588399513361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8052.4468     -8052.4468     -8123.8796     -8123.8796      276.45205      276.45205      24069.779      24069.779      546.2536       546.2536     
     55000  -8056.3553     -8056.3553     -8124.9212     -8124.9212      265.35706      265.35706      24060.045      24060.045      1026.0916      1026.0916    
Loop time of 113.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.612 hours/ns, 8.787 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.22     | 113.22     | 113.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083468   | 0.083468   | 0.083468   |   0.0 |  0.07
Output  | 0.00016936 | 0.00016936 | 0.00016936 |   0.0 |  0.00
Modify  | 0.44164    | 0.44164    | 0.44164    |   0.0 |  0.39
Other   |            | 0.06257    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116172 ave      116172 max      116172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177348377237, Press = 0.609392896915127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8056.3553     -8056.3553     -8124.9212     -8124.9212      265.35706      265.35706      24060.045      24060.045      1026.0916      1026.0916    
     56000  -8054.0398     -8054.0398     -8124.9767     -8124.9767      274.53303      274.53303      24099.584      24099.584     -1993.5178     -1993.5178    
Loop time of 113.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.617 hours/ns, 8.786 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.23     | 113.23     | 113.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083085   | 0.083085   | 0.083085   |   0.0 |  0.07
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.446      | 0.446      | 0.446      |   0.0 |  0.39
Other   |            | 0.06288    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116172 ave      116172 max      116172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.19920565369, Press = 0.574044713239713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8054.0398     -8054.0398     -8124.9767     -8124.9767      274.53303      274.53303      24099.584      24099.584     -1993.5178     -1993.5178    
     57000  -8056.3594     -8056.3594     -8126.3456     -8126.3456      270.85387      270.85387      24074.817      24074.817     -258.7695      -258.7695     
Loop time of 113.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.580 hours/ns, 8.796 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.1      | 113.1      | 113.1      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082891   | 0.082891   | 0.082891   |   0.0 |  0.07
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.44703    | 0.44703    | 0.44703    |   0.0 |  0.39
Other   |            | 0.06271    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116122 ave      116122 max      116122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116122
Ave neighs/atom = 58.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.209352854898, Press = 3.73351184851165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8056.3594     -8056.3594     -8126.3456     -8126.3456      270.85387      270.85387      24074.817      24074.817     -258.7695      -258.7695     
     58000  -8053.8772     -8053.8772     -8124.1178     -8124.1178      271.83832      271.83832      24031.138      24031.138      3424.222       3424.222     
Loop time of 113.995 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.665 hours/ns, 8.772 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.4      | 113.4      | 113.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083002   | 0.083002   | 0.083002   |   0.0 |  0.07
Output  | 0.0002114  | 0.0002114  | 0.0002114  |   0.0 |  0.00
Modify  | 0.44646    | 0.44646    | 0.44646    |   0.0 |  0.39
Other   |            | 0.06285    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116132 ave      116132 max      116132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116132
Ave neighs/atom = 58.066
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.197482290939, Press = 0.759312074767765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8053.8772     -8053.8772     -8124.1178     -8124.1178      271.83832      271.83832      24031.138      24031.138      3424.222       3424.222     
     59000  -8056.7134     -8056.7134     -8125.5282     -8125.5282      266.32069      266.32069      24088.305      24088.305     -1208.8983     -1208.8983    
Loop time of 113.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.601 hours/ns, 8.790 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.18     | 113.18     | 113.18     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082635   | 0.082635   | 0.082635   |   0.0 |  0.07
Output  | 0.00016875 | 0.00016875 | 0.00016875 |   0.0 |  0.00
Modify  | 0.44501    | 0.44501    | 0.44501    |   0.0 |  0.39
Other   |            | 0.06245    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.155502641197, Press = 0.330974905986569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8056.7134     -8056.7134     -8125.5282     -8125.5282      266.32069      266.32069      24088.305      24088.305     -1208.8983     -1208.8983    
     60000  -8053.1662     -8053.1662     -8124.3746     -8124.3746      275.58399      275.58399      24092.987      24092.987     -1155.5538     -1155.5538    
Loop time of 113.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.567 hours/ns, 8.800 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    | 113.05     | 113.05     | 113.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084096   | 0.084096   | 0.084096   |   0.0 |  0.07
Output  | 0.00022002 | 0.00022002 | 0.00022002 |   0.0 |  0.00
Modify  | 0.44714    | 0.44714    | 0.44714    |   0.0 |  0.39
Other   |            | 0.0631     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116150 ave      116150 max      116150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.158007255358, Press = 1.6358752495308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8053.1662     -8053.1662     -8124.3746     -8124.3746      275.58399      275.58399      24092.987      24092.987     -1155.5538     -1155.5538    
     61000  -8058.0006     -8058.0006     -8127.7527     -8127.7527      269.94791      269.94791      24050.308      24050.308      1523.1413      1523.1413    
Loop time of 113.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.457 hours/ns, 8.830 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.65     | 112.65     | 112.65     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084553   | 0.084553   | 0.084553   |   0.0 |  0.07
Output  | 0.00020393 | 0.00020393 | 0.00020393 |   0.0 |  0.00
Modify  | 0.44588    | 0.44588    | 0.44588    |   0.0 |  0.39
Other   |            | 0.06277    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116136 ave      116136 max      116136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116136
Ave neighs/atom = 58.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.130234959918, Press = 1.28318591474506
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8058.0006     -8058.0006     -8127.7527     -8127.7527      269.94791      269.94791      24050.308      24050.308      1523.1413      1523.1413    
     62000  -8054.7066     -8054.7066     -8125.3507     -8125.3507      273.40027      273.40027      24072.687      24072.687      140.16549      140.16549    
Loop time of 113.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.559 hours/ns, 8.802 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    | 113.02     | 113.02     | 113.02     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083557   | 0.083557   | 0.083557   |   0.0 |  0.07
Output  | 0.00021709 | 0.00021709 | 0.00021709 |   0.0 |  0.00
Modify  | 0.44731    | 0.44731    | 0.44731    |   0.0 |  0.39
Other   |            | 0.06332    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.128010252778, Press = 0.219830743582945
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8054.7066     -8054.7066     -8125.3507     -8125.3507      273.40027      273.40027      24072.687      24072.687      140.16549      140.16549    
     63000  -8057.0045     -8057.0045     -8125.465      -8125.465       264.94887      264.94887      24097.913      24097.913     -2000.5386     -2000.5386    
Loop time of 113.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.572 hours/ns, 8.798 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.06     | 113.06     | 113.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084844   | 0.084844   | 0.084844   |   0.0 |  0.07
Output  | 0.00017294 | 0.00017294 | 0.00017294 |   0.0 |  0.00
Modify  | 0.44824    | 0.44824    | 0.44824    |   0.0 |  0.39
Other   |            | 0.06338    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.120885044671, Press = 1.22102602382182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8057.0045     -8057.0045     -8125.465      -8125.465       264.94887      264.94887      24097.913      24097.913     -2000.5386     -2000.5386    
     64000  -8050.9071     -8050.9071     -8123.1553     -8123.1553      279.60802      279.60802      24043.636      24043.636      2569.8918      2569.8918    
Loop time of 112.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.238 hours/ns, 8.892 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.87     | 111.87     | 111.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083016   | 0.083016   | 0.083016   |   0.0 |  0.07
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.44001    | 0.44001    | 0.44001    |   0.0 |  0.39
Other   |            | 0.06326    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116146 ave      116146 max      116146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116146
Ave neighs/atom = 58.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.160742134564, Press = 2.17730794262313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8050.9071     -8050.9071     -8123.1553     -8123.1553      279.60802      279.60802      24043.636      24043.636      2569.8918      2569.8918    
     65000  -8055.283      -8055.283      -8125.6967     -8125.6967      272.5084       272.5084       24051.07       24051.07       1771.2056      1771.2056    
Loop time of 113.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.563 hours/ns, 8.801 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.03     | 113.03     | 113.03     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084718   | 0.084718   | 0.084718   |   0.0 |  0.07
Output  | 0.00017048 | 0.00017048 | 0.00017048 |   0.0 |  0.00
Modify  | 0.4502     | 0.4502     | 0.4502     |   0.0 |  0.40
Other   |            | 0.06368    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
24073.1631996193

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0