# 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.863657325506211*${_u_distance}
variable latticeconst_converted equal 2.863657325506211*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365732550621
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636573 28.636573 28.636573)
  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.636573 28.636573 28.636573)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  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  -8509.4205     -8509.4205     -8580          -8580           273.15         273.15         23483.517      23483.517      3210.2079      3210.2079    
      1000  -8435.9444     -8435.9444     -8503.654      -8503.654       262.04313      262.04313      23730.161      23730.161     -1534.9751     -1534.9751    
Loop time of 139.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.729 hours/ns, 7.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.89     | 138.89     | 138.89     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10371    | 0.10371    | 0.10371    |   0.0 |  0.07
Output  | 0.00021376 | 0.00021376 | 0.00021376 |   0.0 |  0.00
Modify  | 0.37311    | 0.37311    | 0.37311    |   0.0 |  0.27
Other   |            | 0.06089    |            |       |  0.04

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  -8435.9444     -8435.9444     -8503.654      -8503.654       262.04313      262.04313      23730.161      23730.161     -1534.9751     -1534.9751    
      2000  -8436.055      -8436.055      -8505.408      -8505.408       268.40347      268.40347      23708.258      23708.258     -187.15584     -187.15584    
Loop time of 135.161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.545 hours/ns, 7.399 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.67     | 134.67     | 134.67     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098562   | 0.098562   | 0.098562   |   0.0 |  0.07
Output  | 0.00021787 | 0.00021787 | 0.00021787 |   0.0 |  0.00
Modify  | 0.33571    | 0.33571    | 0.33571    |   0.0 |  0.25
Other   |            | 0.05864    |            |       |  0.04

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:       128036 ave      128036 max      128036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128036
Ave neighs/atom = 64.018
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8436.055      -8436.055      -8505.408      -8505.408       268.40347      268.40347      23708.258      23708.258     -187.15584     -187.15584    
      3000  -8437.4691     -8437.4691     -8505.8669     -8505.8669      264.70669      264.70669      23695.161      23695.161      638.80543      638.80543    
Loop time of 135.746 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.707 hours/ns, 7.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.25     | 135.25     | 135.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098425   | 0.098425   | 0.098425   |   0.0 |  0.07
Output  | 0.00021294 | 0.00021294 | 0.00021294 |   0.0 |  0.00
Modify  | 0.33596    | 0.33596    | 0.33596    |   0.0 |  0.25
Other   |            | 0.05787    |            |       |  0.04

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:       128076 ave      128076 max      128076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128076
Ave neighs/atom = 64.038
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8437.4691     -8437.4691     -8505.8669     -8505.8669      264.70669      264.70669      23695.161      23695.161      638.80543      638.80543    
      4000  -8434.6534     -8434.6534     -8506.7351     -8506.7351      278.96383      278.96383      23718.104      23718.104     -882.14936     -882.14936    
Loop time of 135.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.626 hours/ns, 7.383 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.96     | 134.96     | 134.96     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097494   | 0.097494   | 0.097494   |   0.0 |  0.07
Output  | 0.00021075 | 0.00021075 | 0.00021075 |   0.0 |  0.00
Modify  | 0.33703    | 0.33703    | 0.33703    |   0.0 |  0.25
Other   |            | 0.05844    |            |       |  0.04

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:       128044 ave      128044 max      128044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128044
Ave neighs/atom = 64.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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  -8434.6534     -8434.6534     -8506.7351     -8506.7351      278.96383      278.96383      23718.104      23718.104     -882.14936     -882.14936    
      5000  -8438.0574     -8438.0574     -8505.8237     -8505.8237      262.26258      262.26258      23687.231      23687.231      1098.7558      1098.7558    
Loop time of 135.602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.667 hours/ns, 7.375 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.11     | 135.11     | 135.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097583   | 0.097583   | 0.097583   |   0.0 |  0.07
Output  | 0.00017118 | 0.00017118 | 0.00017118 |   0.0 |  0.00
Modify  | 0.3382     | 0.3382     | 0.3382     |   0.0 |  0.25
Other   |            | 0.05839    |            |       |  0.04

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:       128014 ave      128014 max      128014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128014
Ave neighs/atom = 64.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.178301915752, Press = -574.122525695131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.0574     -8438.0574     -8505.8237     -8505.8237      262.26258      262.26258      23687.231      23687.231      1098.7558      1098.7558    
      6000  -8435.4259     -8435.4259     -8506.0617     -8506.0617      273.36774      273.36774      23708.185      23708.185     -208.60747     -208.60747    
Loop time of 143.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.600 ns/day, 39.994 hours/ns, 6.946 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.42     | 143.42     | 143.42     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10304    | 0.10304    | 0.10304    |   0.0 |  0.07
Output  | 0.00016955 | 0.00016955 | 0.00016955 |   0.0 |  0.00
Modify  | 0.39368    | 0.39368    | 0.39368    |   0.0 |  0.27
Other   |            | 0.06147    |            |       |  0.04

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:       128026 ave      128026 max      128026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128026
Ave neighs/atom = 64.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.696524237486, Press = 3.55309090461231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.4259     -8435.4259     -8506.0617     -8506.0617      273.36774      273.36774      23708.185      23708.185     -208.60747     -208.60747    
      7000  -8435.1473     -8435.1473     -8502.9972     -8502.9972      262.5861       262.5861       23742.947      23742.947     -2296.1769     -2296.1769    
Loop time of 136.369 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.880 hours/ns, 7.333 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.85     | 135.85     | 135.85     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097774   | 0.097774   | 0.097774   |   0.0 |  0.07
Output  | 0.00019812 | 0.00019812 | 0.00019812 |   0.0 |  0.00
Modify  | 0.36166    | 0.36166    | 0.36166    |   0.0 |  0.27
Other   |            | 0.05929    |            |       |  0.04

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:       128036 ave      128036 max      128036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128036
Ave neighs/atom = 64.018
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869040707683, Press = -22.8267080347591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.1473     -8435.1473     -8502.9972     -8502.9972      262.5861       262.5861       23742.947      23742.947     -2296.1769     -2296.1769    
      8000  -8437.3988     -8437.3988     -8507.5256     -8507.5256      271.39777      271.39777      23671.527      23671.527      2348.4891      2348.4891    
Loop time of 134.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.391 hours/ns, 7.429 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.1      | 134.1      | 134.1      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096478   | 0.096478   | 0.096478   |   0.0 |  0.07
Output  | 0.00016983 | 0.00016983 | 0.00016983 |   0.0 |  0.00
Modify  | 0.35603    | 0.35603    | 0.35603    |   0.0 |  0.26
Other   |            | 0.05975    |            |       |  0.04

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.345008177859, Press = -29.3199977739248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8437.3988     -8437.3988     -8507.5256     -8507.5256      271.39777      271.39777      23671.527      23671.527      2348.4891      2348.4891    
      9000  -8434.6536     -8434.6536     -8505.9521     -8505.9521      275.9328       275.9328       23696.434      23696.434      820.28452      820.28452    
Loop time of 134.601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.389 hours/ns, 7.429 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.09     | 134.09     | 134.09     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096743   | 0.096743   | 0.096743   |   0.0 |  0.07
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.35514    | 0.35514    | 0.35514    |   0.0 |  0.26
Other   |            | 0.05884    |            |       |  0.04

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:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.154400921131, Press = 5.47174971663539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.6536     -8434.6536     -8505.9521     -8505.9521      275.9328       275.9328       23696.434      23696.434      820.28452      820.28452    
     10000  -8437.9826     -8437.9826     -8507.4274     -8507.4274      268.75868      268.75868      23715.409      23715.409     -959.80651     -959.80651    
Loop time of 134.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.641 ns/day, 37.416 hours/ns, 7.424 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.19     | 134.19     | 134.19     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096366   | 0.096366   | 0.096366   |   0.0 |  0.07
Output  | 0.00020468 | 0.00020468 | 0.00020468 |   0.0 |  0.00
Modify  | 0.35586    | 0.35586    | 0.35586    |   0.0 |  0.26
Other   |            | 0.05945    |            |       |  0.04

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:       128062 ave      128062 max      128062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128062
Ave neighs/atom = 64.031
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.748934173261, Press = -8.02765680936525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8437.9826     -8437.9826     -8507.4274     -8507.4274      268.75868      268.75868      23715.409      23715.409     -959.80651     -959.80651    
     11000  -8436.3151     -8436.3151     -8508.5479     -8508.5479      279.54833      279.54833      23693.7        23693.7        523.09079      523.09079    
Loop time of 134.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.345 hours/ns, 7.438 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.93     | 133.93     | 133.93     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096565   | 0.096565   | 0.096565   |   0.0 |  0.07
Output  | 0.00016812 | 0.00016812 | 0.00016812 |   0.0 |  0.00
Modify  | 0.35586    | 0.35586    | 0.35586    |   0.0 |  0.26
Other   |            | 0.05885    |            |       |  0.04

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:       128040 ave      128040 max      128040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128040
Ave neighs/atom = 64.02
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.698465715209, Press = -8.40781202259669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.3151     -8436.3151     -8508.5479     -8508.5479      279.54833      279.54833      23693.7        23693.7        523.09079      523.09079    
     12000  -8436.9727     -8436.9727     -8507.3707     -8507.3707      272.44735      272.44735      23694.003      23694.003      722.12568      722.12568    
Loop time of 134.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.376 hours/ns, 7.432 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.04     | 134.04     | 134.04     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095777   | 0.095777   | 0.095777   |   0.0 |  0.07
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.35515    | 0.35515    | 0.35515    |   0.0 |  0.26
Other   |            | 0.05917    |            |       |  0.04

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:       128018 ave      128018 max      128018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128018
Ave neighs/atom = 64.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448424407266, Press = -0.915053665802082
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.9727     -8436.9727     -8507.3707     -8507.3707      272.44735      272.44735      23694.003      23694.003      722.12568      722.12568    
     13000  -8437.3263     -8437.3263     -8506.3496     -8506.3496      267.12732      267.12732      23731.496      23731.496     -1867.9317     -1867.9317    
Loop time of 134.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.336 hours/ns, 7.440 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.9      | 133.9      | 133.9      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096572   | 0.096572   | 0.096572   |   0.0 |  0.07
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 0.35564    | 0.35564    | 0.35564    |   0.0 |  0.26
Other   |            | 0.05916    |            |       |  0.04

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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415957768024, Press = -5.45972077278136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8437.3263     -8437.3263     -8506.3496     -8506.3496      267.12732      267.12732      23731.496      23731.496     -1867.9317     -1867.9317    
     14000  -8436.2652     -8436.2652     -8507.8676     -8507.8676      277.10891      277.10891      23684.251      23684.251      1289.2057      1289.2057    
Loop time of 137.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.304 hours/ns, 7.252 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.37     | 137.37     | 137.37     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098158   | 0.098158   | 0.098158   |   0.0 |  0.07
Output  | 0.00039779 | 0.00039779 | 0.00039779 |   0.0 |  0.00
Modify  | 0.36751    | 0.36751    | 0.36751    |   0.0 |  0.27
Other   |            | 0.06007    |            |       |  0.04

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:       128040 ave      128040 max      128040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128040
Ave neighs/atom = 64.02
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.174070792122, Press = -10.1390285212623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.2652     -8436.2652     -8507.8676     -8507.8676      277.10891      277.10891      23684.251      23684.251      1289.2057      1289.2057    
     15000  -8438.009      -8438.009      -8508.23       -8508.23        271.76268      271.76268      23677.306      23677.306      1624.2375      1624.2375    
Loop time of 153.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.514 hours/ns, 6.534 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    | 152.45     | 152.45     | 152.45     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10853    | 0.10853    | 0.10853    |   0.0 |  0.07
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.42938    | 0.42938    | 0.42938    |   0.0 |  0.28
Other   |            | 0.06527    |            |       |  0.04

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:       128042 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.236265939538, Press = 4.47340217146876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.009      -8438.009      -8508.23       -8508.23        271.76268      271.76268      23677.306      23677.306      1624.2375      1624.2375    
     16000  -8434.9422     -8434.9422     -8504.582      -8504.582       269.51338      269.51338      23735.678      23735.678     -1810.4106     -1810.4106    
Loop time of 154.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.559 ns/day, 42.899 hours/ns, 6.475 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    | 153.83     | 153.83     | 153.83     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10979    | 0.10979    | 0.10979    |   0.0 |  0.07
Output  | 0.00016981 | 0.00016981 | 0.00016981 |   0.0 |  0.00
Modify  | 0.43297    | 0.43297    | 0.43297    |   0.0 |  0.28
Other   |            | 0.06547    |            |       |  0.04

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:       128022 ave      128022 max      128022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128022
Ave neighs/atom = 64.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390567263639, Press = -1.88248048897593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.9422     -8434.9422     -8504.582      -8504.582       269.51338      269.51338      23735.678      23735.678     -1810.4106     -1810.4106    
     17000  -8435.7511     -8435.7511     -8505.9866     -8505.9866      271.8187       271.8187       23698.226      23698.226      677.22145      677.22145    
Loop time of 135.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.640 ns/day, 37.521 hours/ns, 7.403 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.56     | 134.56     | 134.56     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098077   | 0.098077   | 0.098077   |   0.0 |  0.07
Output  | 0.0002066  | 0.0002066  | 0.0002066  |   0.0 |  0.00
Modify  | 0.35632    | 0.35632    | 0.35632    |   0.0 |  0.26
Other   |            | 0.05737    |            |       |  0.04

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:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.544342699875, Press = -4.52334773698297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.7511     -8435.7511     -8505.9866     -8505.9866      271.8187       271.8187       23698.226      23698.226      677.22145      677.22145    
     18000  -8436.3843     -8436.3843     -8508.7354     -8508.7354      280.00619      280.00619      23693.943      23693.943      550.5111       550.5111     
Loop time of 135.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.627 hours/ns, 7.382 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.94     | 134.94     | 134.94     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09797    | 0.09797    | 0.09797    |   0.0 |  0.07
Output  | 0.00020721 | 0.00020721 | 0.00020721 |   0.0 |  0.00
Modify  | 0.35729    | 0.35729    | 0.35729    |   0.0 |  0.26
Other   |            | 0.05794    |            |       |  0.04

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:       128054 ave      128054 max      128054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128054
Ave neighs/atom = 64.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.808305210405, Press = -2.32250833064283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.3843     -8436.3843     -8508.7354     -8508.7354      280.00619      280.00619      23693.943      23693.943      550.5111       550.5111     
     19000  -8435.2692     -8435.2692     -8506.6969     -8506.6969      276.43231      276.43231      23716.818      23716.818     -822.95281     -822.95281    
Loop time of 135.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.573 hours/ns, 7.393 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.75     | 134.75     | 134.75     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098203   | 0.098203   | 0.098203   |   0.0 |  0.07
Output  | 0.00016903 | 0.00016903 | 0.00016903 |   0.0 |  0.00
Modify  | 0.35738    | 0.35738    | 0.35738    |   0.0 |  0.26
Other   |            | 0.05785    |            |       |  0.04

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:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.814026235896, Press = -0.771047229686524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.2692     -8435.2692     -8506.6969     -8506.6969      276.43231      276.43231      23716.818      23716.818     -822.95281     -822.95281    
     20000  -8438.2092     -8438.2092     -8507.446      -8507.446       267.95383      267.95383      23718.974      23718.974     -1369.3719     -1369.3719    
Loop time of 135.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.616 hours/ns, 7.385 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.91     | 134.91     | 134.91     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097521   | 0.097521   | 0.097521   |   0.0 |  0.07
Output  | 0.00016985 | 0.00016985 | 0.00016985 |   0.0 |  0.00
Modify  | 0.35633    | 0.35633    | 0.35633    |   0.0 |  0.26
Other   |            | 0.05811    |            |       |  0.04

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:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872096627809, Press = -7.77716610818958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.2092     -8438.2092     -8507.446      -8507.446       267.95383      267.95383      23718.974      23718.974     -1369.3719     -1369.3719    
     21000  -8434.3783     -8434.3783     -8506.7848     -8506.7848      280.22078      280.22078      23657.267      23657.267      3494.3853      3494.3853    
Loop time of 135.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.639 hours/ns, 7.380 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.99     | 134.99     | 134.99     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098439   | 0.098439   | 0.098439   |   0.0 |  0.07
Output  | 0.00016914 | 0.00016914 | 0.00016914 |   0.0 |  0.00
Modify  | 0.35685    | 0.35685    | 0.35685    |   0.0 |  0.26
Other   |            | 0.05749    |            |       |  0.04

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:       128010 ave      128010 max      128010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128010
Ave neighs/atom = 64.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.827497657744, Press = -1.90866789165384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.3783     -8434.3783     -8506.7848     -8506.7848      280.22078      280.22078      23657.267      23657.267      3494.3853      3494.3853    
     22000  -8440.2062     -8440.2062     -8508.7169     -8508.7169      265.14337      265.14337      23712.997      23712.997     -1033.0751     -1033.0751    
Loop time of 135.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.545 hours/ns, 7.398 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.65     | 134.65     | 134.65     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097709   | 0.097709   | 0.097709   |   0.0 |  0.07
Output  | 0.00016995 | 0.00016995 | 0.00016995 |   0.0 |  0.00
Modify  | 0.35799    | 0.35799    | 0.35799    |   0.0 |  0.26
Other   |            | 0.05802    |            |       |  0.04

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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.739809395292, Press = 1.24806334921469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8440.2062     -8440.2062     -8508.7169     -8508.7169      265.14337      265.14337      23712.997      23712.997     -1033.0751     -1033.0751    
     23000  -8435.3964     -8435.3964     -8506.2328     -8506.2328      274.14424      274.14424      23722.418      23722.418     -1094.7035     -1094.7035    
Loop time of 135.257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.571 hours/ns, 7.393 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.75     | 134.75     | 134.75     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096928   | 0.096928   | 0.096928   |   0.0 |  0.07
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.35714    | 0.35714    | 0.35714    |   0.0 |  0.26
Other   |            | 0.05762    |            |       |  0.04

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:       128042 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.678038103201, Press = -4.24326784979288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.3964     -8435.3964     -8506.2328     -8506.2328      274.14424      274.14424      23722.418      23722.418     -1094.7035     -1094.7035    
     24000  -8438.7087     -8438.7087     -8509.6412     -8509.6412      274.51606      274.51606      23680.456      23680.456      1211.5307      1211.5307    
Loop time of 142.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.574 hours/ns, 7.019 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.92     | 141.92     | 141.92     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10164    | 0.10164    | 0.10164    |   0.0 |  0.07
Output  | 0.00021591 | 0.00021591 | 0.00021591 |   0.0 |  0.00
Modify  | 0.38631    | 0.38631    | 0.38631    |   0.0 |  0.27
Other   |            | 0.06012    |            |       |  0.04

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:       128080 ave      128080 max      128080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128080
Ave neighs/atom = 64.04
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.591463280415, Press = -1.38006538436008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.7087     -8438.7087     -8509.6412     -8509.6412      274.51606      274.51606      23680.456      23680.456      1211.5307      1211.5307    
     25000  -8435.7047     -8435.7047     -8506.1056     -8506.1056      272.45885      272.45885      23719.789      23719.789     -859.26452     -859.26452    
Loop time of 156.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.553 ns/day, 43.381 hours/ns, 6.403 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.56     | 155.56     | 155.56     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10882    | 0.10882    | 0.10882    |   0.0 |  0.07
Output  | 0.00016717 | 0.00016717 | 0.00016717 |   0.0 |  0.00
Modify  | 0.44216    | 0.44216    | 0.44216    |   0.0 |  0.28
Other   |            | 0.0648     |            |       |  0.04

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:       128046 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.595462826106, Press = 0.431528611562265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8435.7047     -8435.7047     -8506.1056     -8506.1056      272.45885      272.45885      23719.789      23719.789     -859.26452     -859.26452    
     26000  -8439.4344     -8439.4344     -8507.3485     -8507.3485      262.83481      262.83481      23740.28       23740.28      -2727.4729     -2727.4729    
Loop time of 134.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.378 hours/ns, 7.432 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.05     | 134.05     | 134.05     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096331   | 0.096331   | 0.096331   |   0.0 |  0.07
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.35569    | 0.35569    | 0.35569    |   0.0 |  0.26
Other   |            | 0.05891    |            |       |  0.04

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:       128036 ave      128036 max      128036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128036
Ave neighs/atom = 64.018
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456102866214, Press = -6.29070025221178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8439.4344     -8439.4344     -8507.3485     -8507.3485      262.83481      262.83481      23740.28       23740.28      -2727.4729     -2727.4729    
     27000  -8434.74       -8434.74       -8506.0897     -8506.0897      276.1305       276.1305       23671.621      23671.621      2566.0877      2566.0877    
Loop time of 134.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.641 ns/day, 37.444 hours/ns, 7.418 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.29     | 134.29     | 134.29     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095967   | 0.095967   | 0.095967   |   0.0 |  0.07
Output  | 0.00016924 | 0.00016924 | 0.00016924 |   0.0 |  0.00
Modify  | 0.35554    | 0.35554    | 0.35554    |   0.0 |  0.26
Other   |            | 0.05891    |            |       |  0.04

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:       128028 ave      128028 max      128028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128028
Ave neighs/atom = 64.014
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.437853439838, Press = -1.55181476433543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.74       -8434.74       -8506.0897     -8506.0897      276.1305       276.1305       23671.621      23671.621      2566.0877      2566.0877    
     28000  -8433.2562     -8433.2562     -8504.2558     -8504.2558      274.77605      274.77605      23709.441      23709.441      160.91561      160.91561    
Loop time of 141.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.270 hours/ns, 7.074 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.83     | 140.83     | 140.83     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.07
Output  | 0.00020511 | 0.00020511 | 0.00020511 |   0.0 |  0.00
Modify  | 0.38255    | 0.38255    | 0.38255    |   0.0 |  0.27
Other   |            | 0.06151    |            |       |  0.04

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:       128052 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.479162557908, Press = 0.00275559490491611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8433.2562     -8433.2562     -8504.2558     -8504.2558      274.77605      274.77605      23709.441      23709.441      160.91561      160.91561    
     29000  -8436.4403     -8436.4403     -8505.9696     -8505.9696      269.08548      269.08548      23723.998      23723.998     -1313.3656     -1313.3656    
Loop time of 152.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.242 hours/ns, 6.576 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    | 151.48     | 151.48     | 151.48     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10699    | 0.10699    | 0.10699    |   0.0 |  0.07
Output  | 0.00016818 | 0.00016818 | 0.00016818 |   0.0 |  0.00
Modify  | 0.4236     | 0.4236     | 0.4236     |   0.0 |  0.28
Other   |            | 0.06399    |            |       |  0.04

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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602030522655, Press = -1.791438285078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.4403     -8436.4403     -8505.9696     -8505.9696      269.08548      269.08548      23723.998      23723.998     -1313.3656     -1313.3656    
     30000  -8434.1851     -8434.1851     -8507.5856     -8507.5856      284.06727      284.06727      23680.489      23680.489      1676.7913      1676.7913    
Loop time of 155.444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.179 hours/ns, 6.433 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    | 154.84     | 154.84     | 154.84     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10866    | 0.10866    | 0.10866    |   0.0 |  0.07
Output  | 0.00017004 | 0.00017004 | 0.00017004 |   0.0 |  0.00
Modify  | 0.43447    | 0.43447    | 0.43447    |   0.0 |  0.28
Other   |            | 0.06477    |            |       |  0.04

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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.626298285221, Press = -2.574275915868
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.1851     -8434.1851     -8507.5856     -8507.5856      284.06727      284.06727      23680.489      23680.489      1676.7913      1676.7913    
     31000  -8438.128      -8438.128      -8508.1511     -8508.1511      270.99678      270.99678      23675.227      23675.227      1950.2431      1950.2431    
Loop time of 150.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.922 hours/ns, 6.626 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.33     | 150.33     | 150.33     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1066     | 0.1066     | 0.1066     |   0.0 |  0.07
Output  | 0.00016918 | 0.00016918 | 0.00016918 |   0.0 |  0.00
Modify  | 0.42166    | 0.42166    | 0.42166    |   0.0 |  0.28
Other   |            | 0.06453    |            |       |  0.04

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:       128006 ave      128006 max      128006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128006
Ave neighs/atom = 64.003
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.725253030135, Press = 4.7185688903528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.128      -8438.128      -8508.1511     -8508.1511      270.99678      270.99678      23675.227      23675.227      1950.2431      1950.2431    
     32000  -8434.7264     -8434.7264     -8505.9608     -8505.9608      275.6842       275.6842       23747.374      23747.374     -2879.6715     -2879.6715    
Loop time of 157.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.652 hours/ns, 6.363 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.52     | 156.52     | 156.52     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11118    | 0.11118    | 0.11118    |   0.0 |  0.07
Output  | 0.00023585 | 0.00023585 | 0.00023585 |   0.0 |  0.00
Modify  | 0.44915    | 0.44915    | 0.44915    |   0.0 |  0.29
Other   |            | 0.06632    |            |       |  0.04

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:       128052 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.762758559872, Press = -1.29988243258796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8434.7264     -8434.7264     -8505.9608     -8505.9608      275.6842       275.6842       23747.374      23747.374     -2879.6715     -2879.6715    
     33000  -8438.557      -8438.557      -8508.7637     -8508.7637      271.70694      271.70694      23685.834      23685.834      925.49784      925.49784    
Loop time of 157.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.617 hours/ns, 6.369 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.4      | 156.4      | 156.4      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11013    | 0.11013    | 0.11013    |   0.0 |  0.07
Output  | 0.00016875 | 0.00016875 | 0.00016875 |   0.0 |  0.00
Modify  | 0.44809    | 0.44809    | 0.44809    |   0.0 |  0.29
Other   |            | 0.06659    |            |       |  0.04

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:       128008 ave      128008 max      128008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128008
Ave neighs/atom = 64.004
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.71136593512, Press = -1.8807692520033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8438.557      -8438.557      -8508.7637     -8508.7637      271.70694      271.70694      23685.834      23685.834      925.49784      925.49784    
     34000  -8436.4653     -8436.4653     -8506.7568     -8506.7568      272.0357       272.0357       23690.731      23690.731      974.66366      974.66366    
Loop time of 157.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.732 hours/ns, 6.352 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.81     | 156.81     | 156.81     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1105     | 0.1105     | 0.1105     |   0.0 |  0.07
Output  | 0.00021397 | 0.00021397 | 0.00021397 |   0.0 |  0.00
Modify  | 0.44559    | 0.44559    | 0.44559    |   0.0 |  0.28
Other   |            | 0.06666    |            |       |  0.04

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:       128008 ave      128008 max      128008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128008
Ave neighs/atom = 64.004
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.710337737143, Press = 0.394687231968554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.4653     -8436.4653     -8506.7568     -8506.7568      272.0357       272.0357       23690.731      23690.731      974.66366      974.66366    
     35000  -8433.1094     -8433.1094     -8504.7143     -8504.7143      277.1186       277.1186       23750.109      23750.109     -2787.263      -2787.263     
Loop time of 157.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.699 hours/ns, 6.357 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.69     | 156.69     | 156.69     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.07
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.4449     | 0.4449     | 0.4449     |   0.0 |  0.28
Other   |            | 0.06675    |            |       |  0.04

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:       128046 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.698957607804, Press = -0.82969879355145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8433.1094     -8433.1094     -8504.7143     -8504.7143      277.1186       277.1186       23750.109      23750.109     -2787.263      -2787.263     
     36000  -8436.4961     -8436.4961     -8508.0923     -8508.0923      277.08468      277.08468      23682.689      23682.689      1399.9785      1399.9785    
Loop time of 157.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.698 hours/ns, 6.357 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.69     | 156.69     | 156.69     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1103     | 0.1103     | 0.1103     |   0.0 |  0.07
Output  | 0.00022154 | 0.00022154 | 0.00022154 |   0.0 |  0.00
Modify  | 0.4443     | 0.4443     | 0.4443     |   0.0 |  0.28
Other   |            | 0.06609    |            |       |  0.04

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:       128032 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746502773817, Press = -3.55698878888713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.4961     -8436.4961     -8508.0923     -8508.0923      277.08468      277.08468      23682.689      23682.689      1399.9785      1399.9785    
     37000  -8433.6597     -8433.6597     -8504.2108     -8504.2108      273.04002      273.04002      23682.792      23682.792      1927.0347      1927.0347    
Loop time of 157.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.736 hours/ns, 6.351 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.82     | 156.82     | 156.82     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11073    | 0.11073    | 0.11073    |   0.0 |  0.07
Output  | 0.00025379 | 0.00025379 | 0.00025379 |   0.0 |  0.00
Modify  | 0.44954    | 0.44954    | 0.44954    |   0.0 |  0.29
Other   |            | 0.06682    |            |       |  0.04

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:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.789236047748, Press = 1.31467187383607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8433.6597     -8433.6597     -8504.2108     -8504.2108      273.04002      273.04002      23682.792      23682.792      1927.0347      1927.0347    
     38000  -8436.5251     -8436.5251     -8508.0972     -8508.0972      276.99141      276.99141      23718.096      23718.096     -1146.2495     -1146.2495    
Loop time of 157.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.691 hours/ns, 6.358 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.66     | 156.66     | 156.66     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11074    | 0.11074    | 0.11074    |   0.0 |  0.07
Output  | 0.00017939 | 0.00017939 | 0.00017939 |   0.0 |  0.00
Modify  | 0.44922    | 0.44922    | 0.44922    |   0.0 |  0.29
Other   |            | 0.06599    |            |       |  0.04

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:       128054 ave      128054 max      128054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128054
Ave neighs/atom = 64.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.842076364628, Press = -0.361445694093157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8436.5251     -8436.5251     -8508.0972     -8508.0972      276.99141      276.99141      23718.096      23718.096     -1146.2495     -1146.2495    
     39000  -8432.8244     -8432.8244     -8505.166      -8505.166       279.96952      279.96952      23695.992      23695.992      891.06915      891.06915    
Loop time of 157.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.720 hours/ns, 6.353 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.77     | 156.77     | 156.77     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11052    | 0.11052    | 0.11052    |   0.0 |  0.07
Output  | 0.00016952 | 0.00016952 | 0.00016952 |   0.0 |  0.00
Modify  | 0.448      | 0.448      | 0.448      |   0.0 |  0.28
Other   |            | 0.06671    |            |       |  0.04

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:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.913893113937, Press = -1.27090021417118
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     39000  -8432.8244     -8432.8244     -8505.166      -8505.166       279.96952      279.96952      23695.992      23695.992      891.06915      891.06915    
     40000  -8437.266      -8437.266      -8507.578      -8507.578       272.11461      272.11461      23695.724      23695.724      638.67153      638.67153    
Loop time of 158.161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.934 hours/ns, 6.323 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    | 157.54     | 157.54     | 157.54     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11093    | 0.11093    | 0.11093    |   0.0 |  0.07
Output  | 0.00017139 | 0.00017139 | 0.00017139 |   0.0 |  0.00
Modify  | 0.44854    | 0.44854    | 0.44854    |   0.0 |  0.28
Other   |            | 0.06567    |            |       |  0.04

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:       128052 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.935998997793, Press = 0.943155985993186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     40000  -8437.266      -8437.266      -8507.578      -8507.578       272.11461      272.11461      23695.724      23695.724      638.67153      638.67153    
     41000  -8436.2378     -8436.2378     -8507.0078     -8507.0078      273.88691      273.88691      23765.647      23765.647     -4423.2983     -4423.2983    
Loop time of 157.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.811 hours/ns, 6.340 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    | 157.1      | 157.1      | 157.1      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11038    | 0.11038    | 0.11038    |   0.0 |  0.07
Output  | 0.00021399 | 0.00021399 | 0.00021399 |   0.0 |  0.00
Modify  | 0.44511    | 0.44511    | 0.44511    |   0.0 |  0.28
Other   |            | 0.06487    |            |       |  0.04

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:       128048 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.959178313065, Press = -1.24950743685437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     41000  -8436.2378     -8436.2378     -8507.0078     -8507.0078      273.88691      273.88691      23765.647      23765.647     -4423.2983     -4423.2983    
     42000  -8433.5023     -8433.5023     -8506.836      -8506.836       283.80928      283.80928      23681.792      23681.792      1802.8759      1802.8759    
Loop time of 161.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.535 ns/day, 44.870 hours/ns, 6.191 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    | 160.89     | 160.89     | 160.89     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11286    | 0.11286    | 0.11286    |   0.0 |  0.07
Output  | 0.00026419 | 0.00026419 | 0.00026419 |   0.0 |  0.00
Modify  | 0.4618     | 0.4618     | 0.4618     |   0.0 |  0.29
Other   |            | 0.06698    |            |       |  0.04

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:       128012 ave      128012 max      128012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128012
Ave neighs/atom = 64.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.969513318124, Press = -2.72671323463054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     42000  -8433.5023     -8433.5023     -8506.836      -8506.836       283.80928      283.80928      23681.792      23681.792      1802.8759      1802.8759    
     43000  -8436.6681     -8436.6681     -8507.0222     -8507.0222      272.27744      272.27744      23683.835      23683.835      1520.776       1520.776     
Loop time of 161.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.535 ns/day, 44.860 hours/ns, 6.192 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    | 160.84     | 160.84     | 160.84     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11501    | 0.11501    | 0.11501    |   0.0 |  0.07
Output  | 0.0001602  | 0.0001602  | 0.0001602  |   0.0 |  0.00
Modify  | 0.467      | 0.467      | 0.467      |   0.0 |  0.29
Other   |            | 0.06891    |            |       |  0.04

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:       128034 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.939859864487, Press = 1.25930709428767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     43000  -8436.6681     -8436.6681     -8507.0222     -8507.0222      272.27744      272.27744      23683.835      23683.835      1520.776       1520.776     
     44000  -8433.8746     -8433.8746     -8505.6411     -8505.6411      277.74359      277.74359      23738.213      23738.213     -2118.1386     -2118.1386    
Loop time of 157.744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.818 hours/ns, 6.339 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    | 157.12     | 157.12     | 157.12     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11076    | 0.11076    | 0.11076    |   0.0 |  0.07
Output  | 0.00016165 | 0.00016165 | 0.00016165 |   0.0 |  0.00
Modify  | 0.44711    | 0.44711    | 0.44711    |   0.0 |  0.28
Other   |            | 0.06501    |            |       |  0.04

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:       128046 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.945309782849, Press = -0.141409636500579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     44000  -8433.8746     -8433.8746     -8505.6411     -8505.6411      277.74359      277.74359      23738.213      23738.213     -2118.1386     -2118.1386    
     45000  -8434.7615     -8434.7615     -8507.1026     -8507.1026      279.96775      279.96775      23700.067      23700.067      403.21839      403.21839    
Loop time of 128.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.630 hours/ns, 7.796 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.78     | 127.78     | 127.78     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089204   | 0.089204   | 0.089204   |   0.0 |  0.07
Output  | 0.00016044 | 0.00016044 | 0.00016044 |   0.0 |  0.00
Modify  | 0.3429     | 0.3429     | 0.3429     |   0.0 |  0.27
Other   |            | 0.05758    |            |       |  0.04

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:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.979132086461, Press = -1.47008833025682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     45000  -8434.7615     -8434.7615     -8507.1026     -8507.1026      279.96775      279.96775      23700.067      23700.067      403.21839      403.21839    
     46000  -8436.5156     -8436.5156     -8506.9453     -8506.9453      272.57036      272.57036      23676.791      23676.791      1948.4824      1948.4824    
Loop time of 128.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.696 hours/ns, 7.782 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.02     | 128.02     | 128.02     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089377   | 0.089377   | 0.089377   |   0.0 |  0.07
Output  | 0.00020315 | 0.00020315 | 0.00020315 |   0.0 |  0.00
Modify  | 0.34065    | 0.34065    | 0.34065    |   0.0 |  0.27
Other   |            | 0.05815    |            |       |  0.05

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:       128040 ave      128040 max      128040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128040
Ave neighs/atom = 64.02
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.989843012234, Press = 1.01809572015755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     46000  -8436.5156     -8436.5156     -8506.9453     -8506.9453      272.57036      272.57036      23676.791      23676.791      1948.4824      1948.4824    
     47000  -8435.3661     -8435.3661     -8506.1505     -8506.1505      273.94284      273.94284      23754.164      23754.164     -3423.0666     -3423.0666    
Loop time of 128.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.776 hours/ns, 7.764 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.3      | 128.3      | 128.3      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089681   | 0.089681   | 0.089681   |   0.0 |  0.07
Output  | 0.00016053 | 0.00016053 | 0.00016053 |   0.0 |  0.00
Modify  | 0.34223    | 0.34223    | 0.34223    |   0.0 |  0.27
Other   |            | 0.05835    |            |       |  0.05

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:       128042 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0