# 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.005 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_LeeShimPark_2001_FeCr__MO_150993986463_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_150993986463_001#item-citation

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

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

Performance: 0.851 ns/day, 28.193 hours/ns, 9.853 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    | 100.98     | 100.98     | 100.98     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098197   | 0.098197   | 0.098197   |   0.0 |  0.10
Output  | 0.00021166 | 0.00021166 | 0.00021166 |   0.0 |  0.00
Modify  | 0.35348    | 0.35348    | 0.35348    |   0.0 |  0.35
Other   |            | 0.05969    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8054.1138     -8054.1138     -8127.488      -8127.488       283.96588      283.96588      24077.461      24077.461     -222.37674     -222.37674    
      2000  -8054.8351     -8054.8351     -8125.1612     -8125.1612      272.16916      272.16916      24099.659      24099.659     -2231.6269     -2231.6269    
Loop time of 103.722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.812 hours/ns, 9.641 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097334   | 0.097334   | 0.097334   |   0.0 |  0.09
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 0.35143    | 0.35143    | 0.35143    |   0.0 |  0.34
Other   |            | 0.06001    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8054.8351     -8054.8351     -8125.1612     -8125.1612      272.16916      272.16916      24099.659      24099.659     -2231.6269     -2231.6269    
      3000  -8055.786      -8055.786      -8125.3738     -8125.3738      269.31214      269.31214      24058.144      24058.144      1072.2873      1072.2873    
Loop time of 105.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.265 hours/ns, 9.492 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    | 104.84     | 104.84     | 104.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098091   | 0.098091   | 0.098091   |   0.0 |  0.09
Output  | 0.00020525 | 0.00020525 | 0.00020525 |   0.0 |  0.00
Modify  | 0.35615    | 0.35615    | 0.35615    |   0.0 |  0.34
Other   |            | 0.06015    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8055.786      -8055.786      -8125.3738     -8125.3738      269.31214      269.31214      24058.144      24058.144      1072.2873      1072.2873    
      4000  -8053.7675     -8053.7675     -8125.7813     -8125.7813      278.70109      278.70109      24059.377      24059.377      1171.1505      1171.1505    
Loop time of 105.928 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.424 hours/ns, 9.440 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    | 105.41     | 105.41     | 105.41     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097672   | 0.097672   | 0.097672   |   0.0 |  0.09
Output  | 0.00020145 | 0.00020145 | 0.00020145 |   0.0 |  0.00
Modify  | 0.35705    | 0.35705    | 0.35705    |   0.0 |  0.34
Other   |            | 0.06091    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8053.7675     -8053.7675     -8125.7813     -8125.7813      278.70109      278.70109      24059.377      24059.377      1171.1505      1171.1505    
      5000  -8056.2286     -8056.2286     -8127.5631     -8127.5631      276.07204      276.07204      24117.894      24117.894     -3838.1259     -3838.1259    
Loop time of 106.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.583 hours/ns, 9.390 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    | 105.98     | 105.98     | 105.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098339   | 0.098339   | 0.098339   |   0.0 |  0.09
Output  | 0.00016707 | 0.00016707 | 0.00016707 |   0.0 |  0.00
Modify  | 0.36259    | 0.36259    | 0.36259    |   0.0 |  0.34
Other   |            | 0.06075    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.824 ns/day, 29.137 hours/ns, 9.534 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    | 104.36     | 104.36     | 104.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098219   | 0.098219   | 0.098219   |   0.0 |  0.09
Output  | 0.00016459 | 0.00016459 | 0.00016459 |   0.0 |  0.00
Modify  | 0.37658    | 0.37658    | 0.37658    |   0.0 |  0.36
Other   |            | 0.06046    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.58816310788, Press = 140.204722542514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8053.7902     -8053.7902     -8126.3246     -8126.3246      280.71572      280.71572      24069.948      24069.948      214.32886      214.32886    
      7000  -8058.0137     -8058.0137     -8127.4885     -8127.4885      268.87464      268.87464      24047.186      24047.186      1528.7611      1528.7611    
Loop time of 105.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.308 hours/ns, 9.478 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    | 104.97     | 104.97     | 104.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098315   | 0.098315   | 0.098315   |   0.0 |  0.09
Output  | 0.00016633 | 0.00016633 | 0.00016633 |   0.0 |  0.00
Modify  | 0.37697    | 0.37697    | 0.37697    |   0.0 |  0.36
Other   |            | 0.06045    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127966 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.810 ns/day, 29.646 hours/ns, 9.370 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.18     | 106.18     | 106.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098694   | 0.098694   | 0.098694   |   0.0 |  0.09
Output  | 0.00016323 | 0.00016323 | 0.00016323 |   0.0 |  0.00
Modify  | 0.38257    | 0.38257    | 0.38257    |   0.0 |  0.36
Other   |            | 0.0612     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.807 ns/day, 29.758 hours/ns, 9.335 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.58     | 106.58     | 106.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099108   | 0.099108   | 0.099108   |   0.0 |  0.09
Output  | 0.00019627 | 0.00019627 | 0.00019627 |   0.0 |  0.00
Modify  | 0.38394    | 0.38394    | 0.38394    |   0.0 |  0.36
Other   |            | 0.06071    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127968 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.814 ns/day, 29.468 hours/ns, 9.426 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    | 105.55     | 105.55     | 105.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097643   | 0.097643   | 0.097643   |   0.0 |  0.09
Output  | 0.00016145 | 0.00016145 | 0.00016145 |   0.0 |  0.00
Modify  | 0.38094    | 0.38094    | 0.38094    |   0.0 |  0.36
Other   |            | 0.06071    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.416036968886, Press = 13.767559336671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8053.0528     -8053.0528     -8124.7304     -8124.7304      277.39977      277.39977      24046.49       24046.49       2102.7874      2102.7874    
     11000  -8054.4291     -8054.4291     -8124.8229     -8124.8229      272.43138      272.43138      24070.722      24070.722      175.83331      175.83331    
Loop time of 106.769 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.658 hours/ns, 9.366 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.23     | 106.23     | 106.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098301   | 0.098301   | 0.098301   |   0.0 |  0.09
Output  | 0.00016547 | 0.00016547 | 0.00016547 |   0.0 |  0.00
Modify  | 0.38333    | 0.38333    | 0.38333    |   0.0 |  0.36
Other   |            | 0.06084    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.814 ns/day, 29.489 hours/ns, 9.420 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    | 105.62     | 105.62     | 105.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099471   | 0.099471   | 0.099471   |   0.0 |  0.09
Output  | 0.000163   | 0.000163   | 0.000163   |   0.0 |  0.00
Modify  | 0.381      | 0.381      | 0.381      |   0.0 |  0.36
Other   |            | 0.06079    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.865247026752, Press = 8.74049468884324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8055.0163     -8055.0163     -8126.0753     -8126.0753      275.00548      275.00548      24112.936      24112.936     -3229.4514     -3229.4514    
     13000  -8052.4877     -8052.4877     -8125.4674     -8125.4674      282.43899      282.43899      24056.277      24056.277      1376.3386      1376.3386    
Loop time of 105.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.302 hours/ns, 9.480 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    | 104.95     | 104.95     | 104.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098022   | 0.098022   | 0.098022   |   0.0 |  0.09
Output  | 0.00020284 | 0.00020284 | 0.00020284 |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  0.36
Other   |            | 0.06031    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127952 ave      127952 max      127952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872101294899, Press = 13.9418004566841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8052.4877     -8052.4877     -8125.4674     -8125.4674      282.43899      282.43899      24056.277      24056.277      1376.3386      1376.3386    
     14000  -8054.1105     -8054.1105     -8122.5813     -8122.5813      264.98883      264.98883      24059.21       24059.21       1317.9428      1317.9428    
Loop time of 106.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.680 hours/ns, 9.359 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.3      | 106.3      | 106.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099248   | 0.099248   | 0.099248   |   0.0 |  0.09
Output  | 0.0004323  | 0.0004323  | 0.0004323  |   0.0 |  0.00
Modify  | 0.38382    | 0.38382    | 0.38382    |   0.0 |  0.36
Other   |            | 0.0611     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.901950389546, Press = 2.11927949836762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8054.1105     -8054.1105     -8122.5813     -8122.5813      264.98883      264.98883      24059.21       24059.21       1317.9428      1317.9428    
     15000  -8056.6387     -8056.6387     -8127.8767     -8127.8767      275.69838      275.69838      24091.553      24091.553     -1709.4347     -1709.4347    
Loop time of 106.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.536 hours/ns, 9.405 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    | 105.79     | 105.79     | 105.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099617   | 0.099617   | 0.099617   |   0.0 |  0.09
Output  | 0.0001647  | 0.0001647  | 0.0001647  |   0.0 |  0.00
Modify  | 0.38124    | 0.38124    | 0.38124    |   0.0 |  0.36
Other   |            | 0.06062    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.614083945106, Press = 3.31072803172983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8056.6387     -8056.6387     -8127.8767     -8127.8767      275.69838      275.69838      24091.553      24091.553     -1709.4347     -1709.4347    
     16000  -8056.4772     -8056.4772     -8127.6703     -8127.6703      275.52463      275.52463      24077.11       24077.11      -575.58327     -575.58327    
Loop time of 106.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.508 hours/ns, 9.414 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    | 105.69     | 105.69     | 105.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09933    | 0.09933    | 0.09933    |   0.0 |  0.09
Output  | 0.00016567 | 0.00016567 | 0.00016567 |   0.0 |  0.00
Modify  | 0.38302    | 0.38302    | 0.38302    |   0.0 |  0.36
Other   |            | 0.0609     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.51639506301, Press = 8.53272064640076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8056.4772     -8056.4772     -8127.6703     -8127.6703      275.52463      275.52463      24077.11       24077.11      -575.58327     -575.58327    
     17000  -8051.9972     -8051.9972     -8123.9005     -8123.9005      278.27304      278.27304      24026.805      24026.805      3691.8488      3691.8488    
Loop time of 106.724 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.646 hours/ns, 9.370 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.18     | 106.18     | 106.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098641   | 0.098641   | 0.098641   |   0.0 |  0.09
Output  | 0.00021084 | 0.00021084 | 0.00021084 |   0.0 |  0.00
Modify  | 0.38419    | 0.38419    | 0.38419    |   0.0 |  0.36
Other   |            | 0.06101    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.644374816419, Press = 3.93411981130888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8051.9972     -8051.9972     -8123.9005     -8123.9005      278.27304      278.27304      24026.805      24026.805      3691.8488      3691.8488    
     18000  -8056.6118     -8056.6118     -8126.2145     -8126.2145      269.36979      269.36979      24094.405      24094.405     -1732.6265     -1732.6265    
Loop time of 107.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.727 hours/ns, 9.344 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.47     | 106.47     | 106.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099068   | 0.099068   | 0.099068   |   0.0 |  0.09
Output  | 0.00020792 | 0.00020792 | 0.00020792 |   0.0 |  0.00
Modify  | 0.38411    | 0.38411    | 0.38411    |   0.0 |  0.36
Other   |            | 0.06104    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.621239940338, Press = -2.4264612835544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8056.6118     -8056.6118     -8126.2145     -8126.2145      269.36979      269.36979      24094.405      24094.405     -1732.6265     -1732.6265    
     19000  -8054.4748     -8054.4748     -8124.7703     -8124.7703      272.0509       272.0509       24090.275      24090.275     -1164.1232     -1164.1232    
Loop time of 106.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.682 hours/ns, 9.358 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.31     | 106.31     | 106.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09821    | 0.09821    | 0.09821    |   0.0 |  0.09
Output  | 0.0001622  | 0.0001622  | 0.0001622  |   0.0 |  0.00
Modify  | 0.38431    | 0.38431    | 0.38431    |   0.0 |  0.36
Other   |            | 0.06063    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127960 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.738902838846, Press = 6.19550679382084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8054.4748     -8054.4748     -8124.7703     -8124.7703      272.0509       272.0509       24090.275      24090.275     -1164.1232     -1164.1232    
     20000  -8057.0158     -8057.0158     -8128.285      -8128.285       275.81917      275.81917      24056.377      24056.377      962.39008      962.39008    
Loop time of 106.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.524 hours/ns, 9.408 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    | 105.75     | 105.75     | 105.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099051   | 0.099051   | 0.099051   |   0.0 |  0.09
Output  | 0.00016282 | 0.00016282 | 0.00016282 |   0.0 |  0.00
Modify  | 0.38039    | 0.38039    | 0.38039    |   0.0 |  0.36
Other   |            | 0.06049    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127956 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.781306210035, Press = 5.08791085475421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8057.0158     -8057.0158     -8128.285      -8128.285       275.81917      275.81917      24056.377      24056.377      962.39008      962.39008    
     21000  -8053.2052     -8053.2052     -8125.7293     -8125.7293      280.67577      280.67577      24071.143      24071.143      200.39616      200.39616    
Loop time of 107.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.838 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.87     | 106.87     | 106.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099825   | 0.099825   | 0.099825   |   0.0 |  0.09
Output  | 0.00016293 | 0.00016293 | 0.00016293 |   0.0 |  0.00
Modify  | 0.3838     | 0.3838     | 0.3838     |   0.0 |  0.36
Other   |            | 0.06089    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127966 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.767665329925, Press = 0.8712931962857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8053.2052     -8053.2052     -8125.7293     -8125.7293      280.67577      280.67577      24071.143      24071.143      200.39616      200.39616    
     22000  -8055.2035     -8055.2035     -8125.9693     -8125.9693      273.87101      273.87101      24098.016      24098.016     -2047.5977     -2047.5977    
Loop time of 107.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.836 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.099105   | 0.099105   | 0.099105   |   0.0 |  0.09
Output  | 0.00016454 | 0.00016454 | 0.00016454 |   0.0 |  0.00
Modify  | 0.38421    | 0.38421    | 0.38421    |   0.0 |  0.36
Other   |            | 0.06075    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.764418877097, Press = 3.05067215787048
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8055.2035     -8055.2035     -8125.9693     -8125.9693      273.87101      273.87101      24098.016      24098.016     -2047.5977     -2047.5977    
     23000  -8055.2198     -8055.2198     -8125.7216     -8125.7216      272.84907      272.84907      24056.428      24056.428      1289.8373      1289.8373    
Loop time of 105.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.225 hours/ns, 9.505 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    | 104.67     | 104.67     | 104.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096889   | 0.096889   | 0.096889   |   0.0 |  0.09
Output  | 0.00016451 | 0.00016451 | 0.00016451 |   0.0 |  0.00
Modify  | 0.37662    | 0.37662    | 0.37662    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.653374456232, Press = 7.47368921042532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8055.2198     -8055.2198     -8125.7216     -8125.7216      272.84907      272.84907      24056.428      24056.428      1289.8373      1289.8373    
     24000  -8055.8637     -8055.8637     -8128.1794     -8128.1794      279.86947      279.86947      24026.423      24026.423      3347.4938      3347.4938    
Loop time of 106.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.519 hours/ns, 9.410 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    | 105.73     | 105.73     | 105.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098511   | 0.098511   | 0.098511   |   0.0 |  0.09
Output  | 0.00022747 | 0.00022747 | 0.00022747 |   0.0 |  0.00
Modify  | 0.38083    | 0.38083    | 0.38083    |   0.0 |  0.36
Other   |            | 0.06167    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127966 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.611021338819, Press = 0.334077096099003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8055.8637     -8055.8637     -8128.1794     -8128.1794      279.86947      279.86947      24026.423      24026.423      3347.4938      3347.4938    
     25000  -8055.3083     -8055.3083     -8123.9835     -8123.9835      265.77997      265.77997      24082.905      24082.905     -678.98709     -678.98709    
Loop time of 106.271 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.520 hours/ns, 9.410 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    | 105.73     | 105.73     | 105.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099296   | 0.099296   | 0.099296   |   0.0 |  0.09
Output  | 0.00016436 | 0.00016436 | 0.00016436 |   0.0 |  0.00
Modify  | 0.37867    | 0.37867    | 0.37867    |   0.0 |  0.36
Other   |            | 0.06145    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.479953407021, Press = 1.94420842971133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8055.3083     -8055.3083     -8123.9835     -8123.9835      265.77997      265.77997      24082.905      24082.905     -678.98709     -678.98709    
     26000  -8057.9706     -8057.9706     -8128.1097     -8128.1097      271.44555      271.44555      24077.014      24077.014     -646.62852     -646.62852    
Loop time of 106.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.536 hours/ns, 9.405 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    | 105.79     | 105.79     | 105.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098778   | 0.098778   | 0.098778   |   0.0 |  0.09
Output  | 0.00016775 | 0.00016775 | 0.00016775 |   0.0 |  0.00
Modify  | 0.38165    | 0.38165    | 0.38165    |   0.0 |  0.36
Other   |            | 0.06075    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127968 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.407246841721, Press = 3.42773885245071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8057.9706     -8057.9706     -8128.1097     -8128.1097      271.44555      271.44555      24077.014      24077.014     -646.62852     -646.62852    
     27000  -8053.0878     -8053.0878     -8125.1732     -8125.1732      278.97795      278.97795      24062.377      24062.377      966.2693       966.2693     
Loop time of 105.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.301 hours/ns, 9.480 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    | 104.95     | 104.95     | 104.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097967   | 0.097967   | 0.097967   |   0.0 |  0.09
Output  | 0.0001652  | 0.0001652  | 0.0001652  |   0.0 |  0.00
Modify  | 0.37767    | 0.37767    | 0.37767    |   0.0 |  0.36
Other   |            | 0.06069    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.310564679929, Press = 3.09221692524429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8053.0878     -8053.0878     -8125.1732     -8125.1732      278.97795      278.97795      24062.377      24062.377      966.2693       966.2693     
     28000  -8054.5221     -8054.5221     -8125.5087     -8125.5087      274.72544      274.72544      24062.684      24062.684      860.8425       860.8425     
Loop time of 104.628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.063 hours/ns, 9.558 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    | 104.1      | 104.1      | 104.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097616   | 0.097616   | 0.097616   |   0.0 |  0.09
Output  | 0.00016388 | 0.00016388 | 0.00016388 |   0.0 |  0.00
Modify  | 0.37521    | 0.37521    | 0.37521    |   0.0 |  0.36
Other   |            | 0.05985    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.321216946352, Press = 0.246017242839697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8054.5221     -8054.5221     -8125.5087     -8125.5087      274.72544      274.72544      24062.684      24062.684      860.8425       860.8425     
     29000  -8054.8361     -8054.8361     -8125.8398     -8125.8398      274.79189      274.79189      24117.718      24117.718     -3469.5552     -3469.5552    
Loop time of 106.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.556 hours/ns, 9.398 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    | 105.86     | 105.86     | 105.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098782   | 0.098782   | 0.098782   |   0.0 |  0.09
Output  | 0.00022942 | 0.00022942 | 0.00022942 |   0.0 |  0.00
Modify  | 0.38334    | 0.38334    | 0.38334    |   0.0 |  0.36
Other   |            | 0.06042    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.411741318675, Press = 1.21745330387527
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8054.8361     -8054.8361     -8125.8398     -8125.8398      274.79189      274.79189      24117.718      24117.718     -3469.5552     -3469.5552    
     30000  -8058.0699     -8058.0699     -8125.4311     -8125.4311      260.69471      260.69471      24067.605      24067.605      236.20432      236.20432    
Loop time of 105.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.352 hours/ns, 9.464 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    | 105.13     | 105.13     | 105.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098582   | 0.098582   | 0.098582   |   0.0 |  0.09
Output  | 0.00016766 | 0.00016766 | 0.00016766 |   0.0 |  0.00
Modify  | 0.37716    | 0.37716    | 0.37716    |   0.0 |  0.36
Other   |            | 0.05977    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.312454146119, Press = 5.16122364188343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8058.0699     -8058.0699     -8125.4311     -8125.4311      260.69471      260.69471      24067.605      24067.605      236.20432      236.20432    
     31000  -8054.6943     -8054.6943     -8124.8877     -8124.8877      271.65581      271.65581      24051.828      24051.828      1680.8172      1680.8172    
Loop time of 105.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.363 hours/ns, 9.460 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    | 105.17     | 105.17     | 105.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098803   | 0.098803   | 0.098803   |   0.0 |  0.09
Output  | 0.00021057 | 0.00021057 | 0.00021057 |   0.0 |  0.00
Modify  | 0.37911    | 0.37911    | 0.37911    |   0.0 |  0.36
Other   |            | 0.06061    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.252628420197, Press = 1.97594276886951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8054.6943     -8054.6943     -8124.8877     -8124.8877      271.65581      271.65581      24051.828      24051.828      1680.8172      1680.8172    
     32000  -8055.574      -8055.574      -8127.0276     -8127.0276      276.53246      276.53246      24075.948      24075.948     -360.61868     -360.61868    
Loop time of 105.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.357 hours/ns, 9.462 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    | 105.15     | 105.15     | 105.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098117   | 0.098117   | 0.098117   |   0.0 |  0.09
Output  | 0.00016634 | 0.00016634 | 0.00016634 |   0.0 |  0.00
Modify  | 0.37683    | 0.37683    | 0.37683    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.236841823606, Press = 1.47589633619921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8055.574      -8055.574      -8127.0276     -8127.0276      276.53246      276.53246      24075.948      24075.948     -360.61868     -360.61868    
     33000  -8053.6097     -8053.6097     -8125.8201     -8125.8201      279.46152      279.46152      24077.261      24077.261     -251.90407     -251.90407    
Loop time of 105.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.412 hours/ns, 9.444 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    | 105.34     | 105.34     | 105.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09878    | 0.09878    | 0.09878    |   0.0 |  0.09
Output  | 0.00016413 | 0.00016413 | 0.00016413 |   0.0 |  0.00
Modify  | 0.38213    | 0.38213    | 0.38213    |   0.0 |  0.36
Other   |            | 0.06079    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.269407823594, Press = 2.32723692374353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8053.6097     -8053.6097     -8125.8201     -8125.8201      279.46152      279.46152      24077.261      24077.261     -251.90407     -251.90407    
     34000  -8054.4176     -8054.4176     -8125.5814     -8125.5814      275.41115      275.41115      24063.413      24063.413      835.04915      835.04915    
Loop time of 105.113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.198 hours/ns, 9.514 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    | 104.58     | 104.58     | 104.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097275   | 0.097275   | 0.097275   |   0.0 |  0.09
Output  | 0.00016499 | 0.00016499 | 0.00016499 |   0.0 |  0.00
Modify  | 0.37455    | 0.37455    | 0.37455    |   0.0 |  0.36
Other   |            | 0.06045    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.277874093769, Press = 2.11642058479523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8054.4176     -8054.4176     -8125.5814     -8125.5814      275.41115      275.41115      24063.413      24063.413      835.04915      835.04915    
     35000  -8052.6067     -8052.6067     -8124.7495     -8124.7495      279.2          279.2          24077.375      24077.375     -166.76852     -166.76852    
Loop time of 106.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.704 hours/ns, 9.351 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.39     | 106.39     | 106.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099228   | 0.099228   | 0.099228   |   0.0 |  0.09
Output  | 0.00021015 | 0.00021015 | 0.00021015 |   0.0 |  0.00
Modify  | 0.38413    | 0.38413    | 0.38413    |   0.0 |  0.36
Other   |            | 0.06043    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.347497209442, Press = 0.762946093937323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8052.6067     -8052.6067     -8124.7495     -8124.7495      279.2          279.2          24077.375      24077.375     -166.76852     -166.76852    
     36000  -8056.3016     -8056.3016     -8126.6669     -8126.6669      272.32069      272.32069      24094.692      24094.692     -1930.9298     -1930.9298    
Loop time of 107.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.862 hours/ns, 9.302 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.96     | 106.96     | 106.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099788   | 0.099788   | 0.099788   |   0.0 |  0.09
Output  | 0.00019817 | 0.00019817 | 0.00019817 |   0.0 |  0.00
Modify  | 0.38542    | 0.38542    | 0.38542    |   0.0 |  0.36
Other   |            | 0.06101    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.377807639089, Press = 1.445826039009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8056.3016     -8056.3016     -8126.6669     -8126.6669      272.32069      272.32069      24094.692      24094.692     -1930.9298     -1930.9298    
     37000  -8054.8956     -8054.8956     -8126.5588     -8126.5588      277.34374      277.34374      24064.819      24064.819      533.44039      533.44039    
Loop time of 106.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.694 hours/ns, 9.355 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.35     | 106.35     | 106.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10001    | 0.10001    | 0.10001    |   0.0 |  0.09
Output  | 0.00020583 | 0.00020583 | 0.00020583 |   0.0 |  0.00
Modify  | 0.38437    | 0.38437    | 0.38437    |   0.0 |  0.36
Other   |            | 0.06094    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.382081946953, Press = 3.53571178148727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8054.8956     -8054.8956     -8126.5588     -8126.5588      277.34374      277.34374      24064.819      24064.819      533.44039      533.44039    
     38000  -8059.1317     -8059.1317     -8126.2752     -8126.2752      259.85257      259.85257      24033.919      24033.919      2737.5717      2737.5717    
Loop time of 107.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.860 hours/ns, 9.303 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.95     | 106.95     | 106.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10009    | 0.10009    | 0.10009    |   0.0 |  0.09
Output  | 0.00027951 | 0.00027951 | 0.00027951 |   0.0 |  0.00
Modify  | 0.38728    | 0.38728    | 0.38728    |   0.0 |  0.36
Other   |            | 0.06134    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127968 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.366561877088, Press = 0.849175228078716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8059.1317     -8059.1317     -8126.2752     -8126.2752      259.85257      259.85257      24033.919      24033.919      2737.5717      2737.5717    
     39000  -8054.6048     -8054.6048     -8124.983      -8124.983       272.37082      272.37082      24097.673      24097.673     -1775.9116     -1775.9116    
Loop time of 106.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.576 hours/ns, 9.392 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    | 105.93     | 105.93     | 105.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098953   | 0.098953   | 0.098953   |   0.0 |  0.09
Output  | 0.00016503 | 0.00016503 | 0.00016503 |   0.0 |  0.00
Modify  | 0.38097    | 0.38097    | 0.38097    |   0.0 |  0.36
Other   |            | 0.06043    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0