# 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.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WuLeeSu_2017_NiFe__MO_321233176498_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_321233176498_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 20.7721 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.159 ns/day, 5.770 hours/ns, 48.141 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 20.69      | 20.69      | 20.69      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015529   | 0.015529   | 0.015529   |   0.0 |  0.07
Output  | 0.00012486 | 0.00012486 | 0.00012486 |   0.0 |  0.00
Modify  | 0.060408   | 0.060408   | 0.060408   |   0.0 |  0.29
Other   |            | 0.005726   |            |       |  0.03

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 24.4336 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.536 ns/day, 6.787 hours/ns, 40.927 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.354     | 24.354     | 24.354     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015111   | 0.015111   | 0.015111   |   0.0 |  0.06
Output  | 3.724e-05  | 3.724e-05  | 3.724e-05  |   0.0 |  0.00
Modify  | 0.05952    | 0.05952    | 0.05952    |   0.0 |  0.24
Other   |            | 0.005227   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1128 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.976 hours/ns, 39.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.033     | 25.033     | 25.033     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.06
Output  | 3.3904e-05 | 3.3904e-05 | 3.3904e-05 |   0.0 |  0.00
Modify  | 0.059417   | 0.059417   | 0.059417   |   0.0 |  0.24
Other   |            | 0.005182   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8757 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.473 ns/day, 6.910 hours/ns, 40.200 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.796     | 24.796     | 24.796     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.06
Output  | 3.5166e-05 | 3.5166e-05 | 3.5166e-05 |   0.0 |  0.00
Modify  | 0.05942    | 0.05942    | 0.05942    |   0.0 |  0.24
Other   |            | 0.005151   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9683 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.460 ns/day, 6.936 hours/ns, 40.051 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.888     | 24.888     | 24.888     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.06
Output  | 2.7642e-05 | 2.7642e-05 | 2.7642e-05 |   0.0 |  0.00
Modify  | 0.059599   | 0.059599   | 0.059599   |   0.0 |  0.24
Other   |            | 0.005175   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.469 ns/day, 6.919 hours/ns, 40.148 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.826     | 24.826     | 24.826     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015118   | 0.015118   | 0.015118   |   0.0 |  0.06
Output  | 2.8153e-05 | 2.8153e-05 | 2.8153e-05 |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.25
Other   |            | 0.005239   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8618 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.475 ns/day, 6.906 hours/ns, 40.222 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.78      | 24.78      | 24.78      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.06
Output  | 2.2011e-05 | 2.2011e-05 | 2.2011e-05 |   0.0 |  0.00
Modify  | 0.061619   | 0.061619   | 0.061619   |   0.0 |  0.25
Other   |            | 0.005224   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.456 ns/day, 6.944 hours/ns, 40.005 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.915     | 24.915     | 24.915     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015107   | 0.015107   | 0.015107   |   0.0 |  0.06
Output  | 2.8073e-05 | 2.8073e-05 | 2.8073e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.25
Other   |            | 0.005227   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8725 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.474 ns/day, 6.909 hours/ns, 40.205 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.791     | 24.791     | 24.791     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.06
Output  | 2.3124e-05 | 2.3124e-05 | 2.3124e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.25
Other   |            | 0.005283   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9669 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.461 ns/day, 6.935 hours/ns, 40.053 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.885     | 24.885     | 24.885     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.06
Output  | 2.9465e-05 | 2.9465e-05 | 2.9465e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.25
Other   |            | 0.005225   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9513 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.463 ns/day, 6.931 hours/ns, 40.078 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.869     | 24.869     | 24.869     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01505    | 0.01505    | 0.01505    |   0.0 |  0.06
Output  | 2.179e-05  | 2.179e-05  | 2.179e-05  |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.25
Other   |            | 0.005226   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.476 ns/day, 6.904 hours/ns, 40.232 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.774     | 24.774     | 24.774     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015064   | 0.015064   | 0.015064   |   0.0 |  0.06
Output  | 2.7792e-05 | 2.7792e-05 | 2.7792e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.25
Other   |            | 0.005249   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8822 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.472 ns/day, 6.912 hours/ns, 40.189 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.8       | 24.8       | 24.8       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014981   | 0.014981   | 0.014981   |   0.0 |  0.06
Output  | 2.1681e-05 | 2.1681e-05 | 2.1681e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.25
Other   |            | 0.00523    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8908 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.471 ns/day, 6.914 hours/ns, 40.175 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.809     | 24.809     | 24.809     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.06
Output  | 7.2606e-05 | 7.2606e-05 | 7.2606e-05 |   0.0 |  0.00
Modify  | 0.061637   | 0.061637   | 0.061637   |   0.0 |  0.25
Other   |            | 0.005238   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9895 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.457 ns/day, 6.942 hours/ns, 40.017 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.907     | 24.907     | 24.907     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01498    | 0.01498    | 0.01498    |   0.0 |  0.06
Output  | 2.9485e-05 | 2.9485e-05 | 2.9485e-05 |   0.0 |  0.00
Modify  | 0.061684   | 0.061684   | 0.061684   |   0.0 |  0.25
Other   |            | 0.005283   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0238 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.453 ns/day, 6.951 hours/ns, 39.962 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.942     | 24.942     | 24.942     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014976   | 0.014976   | 0.014976   |   0.0 |  0.06
Output  | 2.1901e-05 | 2.1901e-05 | 2.1901e-05 |   0.0 |  0.00
Modify  | 0.061608   | 0.061608   | 0.061608   |   0.0 |  0.25
Other   |            | 0.005314   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9192 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.467 ns/day, 6.922 hours/ns, 40.130 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.837     | 24.837     | 24.837     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.06
Output  | 2.8062e-05 | 2.8062e-05 | 2.8062e-05 |   0.0 |  0.00
Modify  | 0.061749   | 0.061749   | 0.061749   |   0.0 |  0.25
Other   |            | 0.005268   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0726 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.446 ns/day, 6.965 hours/ns, 39.884 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.991     | 24.991     | 24.991     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.06
Output  | 2.2112e-05 | 2.2112e-05 | 2.2112e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.25
Other   |            | 0.005224   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9754 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.459 ns/day, 6.938 hours/ns, 40.039 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.893     | 24.893     | 24.893     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015074   | 0.015074   | 0.015074   |   0.0 |  0.06
Output  | 2.2122e-05 | 2.2122e-05 | 2.2122e-05 |   0.0 |  0.00
Modify  | 0.061738   | 0.061738   | 0.061738   |   0.0 |  0.25
Other   |            | 0.005251   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.472 ns/day, 6.912 hours/ns, 40.190 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.8       | 24.8       | 24.8       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01513    | 0.01513    | 0.01513    |   0.0 |  0.06
Output  | 8.5099e-05 | 8.5099e-05 | 8.5099e-05 |   0.0 |  0.00
Modify  | 0.061779   | 0.061779   | 0.061779   |   0.0 |  0.25
Other   |            | 0.005303   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9909 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.457 ns/day, 6.942 hours/ns, 40.015 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.909     | 24.909     | 24.909     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014932   | 0.014932   | 0.014932   |   0.0 |  0.06
Output  | 3.6259e-05 | 3.6259e-05 | 3.6259e-05 |   0.0 |  0.00
Modify  | 0.061572   | 0.061572   | 0.061572   |   0.0 |  0.25
Other   |            | 0.005385   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9138 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.468 ns/day, 6.920 hours/ns, 40.138 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.831     | 24.831     | 24.831     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015164   | 0.015164   | 0.015164   |   0.0 |  0.06
Output  | 5.8409e-05 | 5.8409e-05 | 5.8409e-05 |   0.0 |  0.00
Modify  | 0.06194    | 0.06194    | 0.06194    |   0.0 |  0.25
Other   |            | 0.005528   |            |       |  0.02

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 24.9603 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.462 ns/day, 6.933 hours/ns, 40.064 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.878     | 24.878     | 24.878     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015048   | 0.015048   | 0.015048   |   0.0 |  0.06
Output  | 5.2379e-05 | 5.2379e-05 | 5.2379e-05 |   0.0 |  0.00
Modify  | 0.062041   | 0.062041   | 0.062041   |   0.0 |  0.25
Other   |            | 0.005555   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9276 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.466 ns/day, 6.924 hours/ns, 40.116 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.845     | 24.845     | 24.845     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.06
Output  | 5.6796e-05 | 5.6796e-05 | 5.6796e-05 |   0.0 |  0.00
Modify  | 0.06182    | 0.06182    | 0.06182    |   0.0 |  0.25
Other   |            | 0.005522   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.8848 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.472 ns/day, 6.912 hours/ns, 40.185 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.803     | 24.803     | 24.803     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.06
Output  | 2.9967e-05 | 2.9967e-05 | 2.9967e-05 |   0.0 |  0.00
Modify  | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.25
Other   |            | 0.005512   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9452 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.464 ns/day, 6.929 hours/ns, 40.088 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.863     | 24.863     | 24.863     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014981   | 0.014981   | 0.014981   |   0.0 |  0.06
Output  | 2.2993e-05 | 2.2993e-05 | 2.2993e-05 |   0.0 |  0.00
Modify  | 0.061777   | 0.061777   | 0.061777   |   0.0 |  0.25
Other   |            | 0.005512   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1182 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.977 hours/ns, 39.812 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.036     | 25.036     | 25.036     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015097   | 0.015097   | 0.015097   |   0.0 |  0.06
Output  | 4.2039e-05 | 4.2039e-05 | 4.2039e-05 |   0.0 |  0.00
Modify  | 0.061803   | 0.061803   | 0.061803   |   0.0 |  0.25
Other   |            | 0.005533   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0065 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.455 ns/day, 6.946 hours/ns, 39.990 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.924     | 24.924     | 24.924     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.06
Output  | 3.6058e-05 | 3.6058e-05 | 3.6058e-05 |   0.0 |  0.00
Modify  | 0.061692   | 0.061692   | 0.061692   |   0.0 |  0.25
Other   |            | 0.005514   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0841 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.444 ns/day, 6.968 hours/ns, 39.866 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.002     | 25.002     | 25.002     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015097   | 0.015097   | 0.015097   |   0.0 |  0.06
Output  | 2.6751e-05 | 2.6751e-05 | 2.6751e-05 |   0.0 |  0.00
Modify  | 0.061793   | 0.061793   | 0.061793   |   0.0 |  0.25
Other   |            | 0.00551    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0345 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.451 ns/day, 6.954 hours/ns, 39.945 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.952     | 24.952     | 24.952     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.06
Output  | 3.0498e-05 | 3.0498e-05 | 3.0498e-05 |   0.0 |  0.00
Modify  | 0.061748   | 0.061748   | 0.061748   |   0.0 |  0.25
Other   |            | 0.005531   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.2033 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.428 ns/day, 7.001 hours/ns, 39.677 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.121     | 25.121     | 25.121     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.06
Output  | 3.706e-05  | 3.706e-05  | 3.706e-05  |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.24
Other   |            | 0.005521   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0323 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.953 hours/ns, 39.948 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.95      | 24.95      | 24.95      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015105   | 0.015105   | 0.015105   |   0.0 |  0.06
Output  | 3.0297e-05 | 3.0297e-05 | 3.0297e-05 |   0.0 |  0.00
Modify  | 0.06176    | 0.06176    | 0.06176    |   0.0 |  0.25
Other   |            | 0.005515   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 24.9079 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.469 ns/day, 6.919 hours/ns, 40.148 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.825     | 24.825     | 24.825     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.06
Output  | 3.7009e-05 | 3.7009e-05 | 3.7009e-05 |   0.0 |  0.00
Modify  | 0.061813   | 0.061813   | 0.061813   |   0.0 |  0.25
Other   |            | 0.005549   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0804 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.445 ns/day, 6.967 hours/ns, 39.872 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.998     | 24.998     | 24.998     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.06
Output  | 4.1187e-05 | 4.1187e-05 | 4.1187e-05 |   0.0 |  0.00
Modify  | 0.061845   | 0.061845   | 0.061845   |   0.0 |  0.25
Other   |            | 0.005505   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0648 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.962 hours/ns, 39.897 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.982     | 24.982     | 24.982     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015086   | 0.015086   | 0.015086   |   0.0 |  0.06
Output  | 2.3784e-05 | 2.3784e-05 | 2.3784e-05 |   0.0 |  0.00
Modify  | 0.061741   | 0.061741   | 0.061741   |   0.0 |  0.25
Other   |            | 0.005503   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.2395 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.423 ns/day, 7.011 hours/ns, 39.620 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.157     | 25.157     | 25.157     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.06
Output  | 2.3945e-05 | 2.3945e-05 | 2.3945e-05 |   0.0 |  0.00
Modify  | 0.061905   | 0.061905   | 0.061905   |   0.0 |  0.25
Other   |            | 0.005517   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1806 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.431 ns/day, 6.995 hours/ns, 39.713 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.098     | 25.098     | 25.098     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.06
Output  | 5.4372e-05 | 5.4372e-05 | 5.4372e-05 |   0.0 |  0.00
Modify  | 0.061953   | 0.061953   | 0.061953   |   0.0 |  0.25
Other   |            | 0.005536   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1154 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.977 hours/ns, 39.816 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.033     | 25.033     | 25.033     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.06
Output  | 2.3334e-05 | 2.3334e-05 | 2.3334e-05 |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.25
Other   |            | 0.005498   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1273 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.797 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.045     | 25.045     | 25.045     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015088   | 0.015088   | 0.015088   |   0.0 |  0.06
Output  | 4.3912e-05 | 4.3912e-05 | 4.3912e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.25
Other   |            | 0.005539   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0639 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.962 hours/ns, 39.898 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.982     | 24.982     | 24.982     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015037   | 0.015037   | 0.015037   |   0.0 |  0.06
Output  | 3.5617e-05 | 3.5617e-05 | 3.5617e-05 |   0.0 |  0.00
Modify  | 0.061727   | 0.061727   | 0.061727   |   0.0 |  0.25
Other   |            | 0.005527   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0657 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.963 hours/ns, 39.895 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.983     | 24.983     | 24.983     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.06
Output  | 4.1338e-05 | 4.1338e-05 | 4.1338e-05 |   0.0 |  0.00
Modify  | 0.061812   | 0.061812   | 0.061812   |   0.0 |  0.25
Other   |            | 0.005525   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0486 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.449 ns/day, 6.958 hours/ns, 39.922 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.966     | 24.966     | 24.966     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.06
Output  | 3.4855e-05 | 3.4855e-05 | 3.4855e-05 |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.25
Other   |            | 0.005518   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0733 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.446 ns/day, 6.965 hours/ns, 39.883 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    | 24.991     | 24.991     | 24.991     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.06
Output  | 2.3524e-05 | 2.3524e-05 | 2.3524e-05 |   0.0 |  0.00
Modify  | 0.061638   | 0.061638   | 0.061638   |   0.0 |  0.25
Other   |            | 0.005501   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1071 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.441 ns/day, 6.974 hours/ns, 39.829 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    | 25.025     | 25.025     | 25.025     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015078   | 0.015078   | 0.015078   |   0.0 |  0.06
Output  | 3.0868e-05 | 3.0868e-05 | 3.0868e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.25
Other   |            | 0.005539   |            |       |  0.02

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 24.9633 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.461 ns/day, 6.934 hours/ns, 40.059 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    | 24.881     | 24.881     | 24.881     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.06
Output  | 2.2892e-05 | 2.2892e-05 | 2.2892e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.25
Other   |            | 0.005523   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.1426 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.436 ns/day, 6.984 hours/ns, 39.773 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    | 25.06      | 25.06      | 25.06      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.06
Output  | 3.1579e-05 | 3.1579e-05 | 3.1579e-05 |   0.0 |  0.00
Modify  | 0.061685   | 0.061685   | 0.061685   |   0.0 |  0.25
Other   |            | 0.005498   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 25.0542 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.449 ns/day, 6.960 hours/ns, 39.913 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    | 24.972     | 24.972     | 24.972     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015109   | 0.015109   | 0.015109   |   0.0 |  0.06
Output  | 2.3394e-05 | 2.3394e-05 | 2.3394e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.25
Other   |            | 0.005499   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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