# 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 4.049985826015473*${_u_distance}
variable latticeconst_converted equal 4.049985826015473*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04998582601547
Lattice spacing in x,y,z = 4.0499858 4.0499858 4.0499858
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.499858 40.499858 40.499858)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.499858 40.499858 40.499858)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_SunRamachandranWick_2018_TiAl__MO_022920256108_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66429.4275360972 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_022920256108_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 = 14 14 14
  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) = 4.143 | 4.143 | 4.143 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13271.351     -13271.351     -13412.545     -13412.545      273.15         273.15         66429.428      66429.428      2270.2485      2270.2485    
      1000  -13117.532     -13117.532     -13259.545     -13259.545      274.73411      274.73411      67436.62       67436.62      -634.58673     -634.58673    
Loop time of 39.5452 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.185 ns/day, 10.985 hours/ns, 25.288 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    | 39.403     | 39.403     | 39.403     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015047   | 0.015047   | 0.015047   |   0.0 |  0.04
Output  | 0.00012937 | 0.00012937 | 0.00012937 |   0.0 |  0.00
Modify  | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.30
Other   |            | 0.009453   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 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:       216000 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13117.532     -13117.532     -13259.545     -13259.545      274.73411      274.73411      67436.62       67436.62      -634.58673     -634.58673    
      2000  -13129.736     -13129.736     -13268.209     -13268.209      267.88507      267.88507      67319.882      67319.882      12.75871       12.75871     
Loop time of 44.3328 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.949 ns/day, 12.315 hours/ns, 22.557 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.188     | 44.188     | 44.188     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016406   | 0.016406   | 0.016406   |   0.0 |  0.04
Output  | 4.8311e-05 | 4.8311e-05 | 4.8311e-05 |   0.0 |  0.00
Modify  | 0.11871    | 0.11871    | 0.11871    |   0.0 |  0.27
Other   |            | 0.00972    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4065 ave        4065 max        4065 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:       214992 ave      214992 max      214992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214992
Ave neighs/atom = 53.748
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13129.736     -13129.736     -13268.209     -13268.209      267.88507      267.88507      67319.882      67319.882      12.75871       12.75871     
      3000  -13125.188     -13125.188     -13265.783     -13265.783      271.99009      271.99009      67304.126      67304.126      294.52334      294.52334    
Loop time of 44.6281 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.397 hours/ns, 22.407 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.485     | 44.485     | 44.485     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01602    | 0.01602    | 0.01602    |   0.0 |  0.04
Output  | 7.8378e-05 | 7.8378e-05 | 7.8378e-05 |   0.0 |  0.00
Modify  | 0.11791    | 0.11791    | 0.11791    |   0.0 |  0.26
Other   |            | 0.009535   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4035 ave        4035 max        4035 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:       215216 ave      215216 max      215216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215216
Ave neighs/atom = 53.804
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13125.188     -13125.188     -13265.783     -13265.783      271.99009      271.99009      67304.126      67304.126      294.52334      294.52334    
      4000  -13125.142     -13125.142     -13268.802     -13268.802      277.92021      277.92021      67372.23       67372.23      -413.11033     -413.11033    
Loop time of 44.6318 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.398 hours/ns, 22.406 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.488     | 44.488     | 44.488     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015984   | 0.015984   | 0.015984   |   0.0 |  0.04
Output  | 4.9082e-05 | 4.9082e-05 | 4.9082e-05 |   0.0 |  0.00
Modify  | 0.11796    | 0.11796    | 0.11796    |   0.0 |  0.26
Other   |            | 0.009592   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4054 ave        4054 max        4054 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:       215242 ave      215242 max      215242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215242
Ave neighs/atom = 53.8105
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13125.142     -13125.142     -13268.802     -13268.802      277.92021      277.92021      67372.23       67372.23      -413.11033     -413.11033    
      5000  -13127.707     -13127.707     -13268.892     -13268.892      273.1331       273.1331       67294.709      67294.709      259.28253      259.28253    
Loop time of 44.6102 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.937 ns/day, 12.392 hours/ns, 22.416 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.466     | 44.466     | 44.466     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015932   | 0.015932   | 0.015932   |   0.0 |  0.04
Output  | 3.9143e-05 | 3.9143e-05 | 3.9143e-05 |   0.0 |  0.00
Modify  | 0.11842    | 0.11842    | 0.11842    |   0.0 |  0.27
Other   |            | 0.009613   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4024 ave        4024 max        4024 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:       215176 ave      215176 max      215176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215176
Ave neighs/atom = 53.794
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 = 270.687494358227, Press = 354.140816615458
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13127.707     -13127.707     -13268.892     -13268.892      273.1331       273.1331       67294.709      67294.709      259.28253      259.28253    
      6000  -13125.119     -13125.119     -13267.354     -13267.354      275.16214      275.16214      67294.748      67294.748      358.18443      358.18443    
Loop time of 44.5644 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.379 hours/ns, 22.439 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.416     | 44.416     | 44.416     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016273   | 0.016273   | 0.016273   |   0.0 |  0.04
Output  | 0.00010387 | 0.00010387 | 0.00010387 |   0.0 |  0.00
Modify  | 0.12197    | 0.12197    | 0.12197    |   0.0 |  0.27
Other   |            | 0.009655   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4081 ave        4081 max        4081 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:       215132 ave      215132 max      215132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215132
Ave neighs/atom = 53.783
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.758691530094, Press = -14.7534570697244
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13125.119     -13125.119     -13267.354     -13267.354      275.16214      275.16214      67294.748      67294.748      358.18443      358.18443    
      7000  -13127.607     -13127.607     -13266.465     -13266.465      268.63001      268.63001      67455.724      67455.724     -1170.6956     -1170.6956    
Loop time of 44.6742 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.934 ns/day, 12.409 hours/ns, 22.384 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.527     | 44.527     | 44.527     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015879   | 0.015879   | 0.015879   |   0.0 |  0.04
Output  | 3.7882e-05 | 3.7882e-05 | 3.7882e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.27
Other   |            | 0.009513   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4051 ave        4051 max        4051 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:       215248 ave      215248 max      215248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215248
Ave neighs/atom = 53.812
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.159837604597, Press = 15.1969138130486
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13127.607     -13127.607     -13266.465     -13266.465      268.63001      268.63001      67455.724      67455.724     -1170.6956     -1170.6956    
      8000  -13124.621     -13124.621     -13264.889     -13264.889      271.35841      271.35841      67265.119      67265.119      726.08363      726.08363    
Loop time of 44.5422 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.940 ns/day, 12.373 hours/ns, 22.451 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.395     | 44.395     | 44.395     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015935   | 0.015935   | 0.015935   |   0.0 |  0.04
Output  | 0.00016241 | 0.00016241 | 0.00016241 |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.27
Other   |            | 0.009605   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4005 ave        4005 max        4005 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:       215048 ave      215048 max      215048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215048
Ave neighs/atom = 53.762
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.838239100013, Press = 10.0738450430677
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13124.621     -13124.621     -13264.889     -13264.889      271.35841      271.35841      67265.119      67265.119      726.08363      726.08363    
      9000  -13129.735     -13129.735     -13270.175     -13270.175      271.68896      271.68896      67333.326      67333.326     -171.7542      -171.7542     
Loop time of 44.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.935 ns/day, 12.406 hours/ns, 22.390 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.514     | 44.514     | 44.514     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016212   | 0.016212   | 0.016212   |   0.0 |  0.04
Output  | 0.0001323  | 0.0001323  | 0.0001323  |   0.0 |  0.00
Modify  | 0.12223    | 0.12223    | 0.12223    |   0.0 |  0.27
Other   |            | 0.009687   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4077 ave        4077 max        4077 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:       215206 ave      215206 max      215206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215206
Ave neighs/atom = 53.8015
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.492650875012, Press = 2.16063624355065
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13129.735     -13129.735     -13270.175     -13270.175      271.68896      271.68896      67333.326      67333.326     -171.7542      -171.7542     
     10000  -13125.944     -13125.944     -13268.775     -13268.775      276.31644      276.31644      67352.263      67352.263     -238.94742     -238.94742    
Loop time of 44.6997 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.933 ns/day, 12.417 hours/ns, 22.372 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.551     | 44.551     | 44.551     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016042   | 0.016042   | 0.016042   |   0.0 |  0.04
Output  | 4.265e-05  | 4.265e-05  | 4.265e-05  |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.27
Other   |            | 0.009824   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 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:       215200 ave      215200 max      215200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215200
Ave neighs/atom = 53.8
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.552091173365, Press = 4.74318859260978
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13125.944     -13125.944     -13268.775     -13268.775      276.31644      276.31644      67352.263      67352.263     -238.94742     -238.94742    
     11000  -13130.628     -13130.628     -13271.21      -13271.21       271.96448      271.96448      67275.033      67275.033      359.6998       359.6998     
Loop time of 44.5053 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.941 ns/day, 12.363 hours/ns, 22.469 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.359     | 44.359     | 44.359     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015659   | 0.015659   | 0.015659   |   0.0 |  0.04
Output  | 6.7356e-05 | 6.7356e-05 | 6.7356e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.27
Other   |            | 0.009529   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4061 ave        4061 max        4061 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:       215246 ave      215246 max      215246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215246
Ave neighs/atom = 53.8115
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.268317869705, Press = 3.13179412909788
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13130.628     -13130.628     -13271.21      -13271.21       271.96448      271.96448      67275.033      67275.033      359.6998       359.6998     
     12000  -13124.099     -13124.099     -13266.242     -13266.242      274.98478      274.98478      67367.886      67367.886     -267.88138     -267.88138    
Loop time of 44.6269 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.396 hours/ns, 22.408 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.481     | 44.481     | 44.481     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015532   | 0.015532   | 0.015532   |   0.0 |  0.03
Output  | 2.9065e-05 | 2.9065e-05 | 2.9065e-05 |   0.0 |  0.00
Modify  | 0.12077    | 0.12077    | 0.12077    |   0.0 |  0.27
Other   |            | 0.009438   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4032 ave        4032 max        4032 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:       215296 ave      215296 max      215296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215296
Ave neighs/atom = 53.824
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.302857309423, Press = 0.204539471366998
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13124.099     -13124.099     -13266.242     -13266.242      274.98478      274.98478      67367.886      67367.886     -267.88138     -267.88138    
     13000  -13129.406     -13129.406     -13269.296     -13269.296      270.62777      270.62777      67343.265      67343.265     -202.48835     -202.48835    
Loop time of 44.3514 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.205     | 44.205     | 44.205     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015691   | 0.015691   | 0.015691   |   0.0 |  0.04
Output  | 0.0001042  | 0.0001042  | 0.0001042  |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.27
Other   |            | 0.009407   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4052 ave        4052 max        4052 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:       215132 ave      215132 max      215132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215132
Ave neighs/atom = 53.783
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.329609440989, Press = 4.7412495605378
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13129.406     -13129.406     -13269.296     -13269.296      270.62777      270.62777      67343.265      67343.265     -202.48835     -202.48835    
     14000  -13127.565     -13127.565     -13267.699     -13267.699      271.09917      271.09917      67226.327      67226.327      1009.0361      1009.0361    
Loop time of 44.5694 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.380 hours/ns, 22.437 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.423     | 44.423     | 44.423     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015838   | 0.015838   | 0.015838   |   0.0 |  0.04
Output  | 0.0001161  | 0.0001161  | 0.0001161  |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.27
Other   |            | 0.00966    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4088 ave        4088 max        4088 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:       215216 ave      215216 max      215216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215216
Ave neighs/atom = 53.804
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.442164989313, Press = 0.41436794858339
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13127.565     -13127.565     -13267.699     -13267.699      271.09917      271.09917      67226.327      67226.327      1009.0361      1009.0361    
     15000  -13124.268     -13124.268     -13267.033     -13267.033      276.18771      276.18771      67461.387      67461.387     -1179.8029     -1179.8029    
Loop time of 44.5588 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.377 hours/ns, 22.442 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.412     | 44.412     | 44.412     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015768   | 0.015768   | 0.015768   |   0.0 |  0.04
Output  | 4.5155e-05 | 4.5155e-05 | 4.5155e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.27
Other   |            | 0.009722   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 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:       215242 ave      215242 max      215242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215242
Ave neighs/atom = 53.8105
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.518045687251, Press = -0.576616957314036
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13124.268     -13124.268     -13267.033     -13267.033      276.18771      276.18771      67461.387      67461.387     -1179.8029     -1179.8029    
     16000  -13129.017     -13129.017     -13267.614     -13267.614      268.1265       268.1265       67306.264      67306.264      209.00337      209.00337    
Loop time of 44.5576 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.377 hours/ns, 22.443 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.411     | 44.411     | 44.411     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015663   | 0.015663   | 0.015663   |   0.0 |  0.04
Output  | 3.192e-05  | 3.192e-05  | 3.192e-05  |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.27
Other   |            | 0.009511   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4033 ave        4033 max        4033 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:       215130 ave      215130 max      215130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215130
Ave neighs/atom = 53.7825
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.561218255983, Press = 3.10021367925013
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13129.017     -13129.017     -13267.614     -13267.614      268.1265       268.1265       67306.264      67306.264      209.00337      209.00337    
     17000  -13124.285     -13124.285     -13268.069     -13268.069      278.16035      278.16035      67313.517      67313.517      182.01145      182.01145    
Loop time of 44.4544 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.944 ns/day, 12.348 hours/ns, 22.495 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.309     | 44.309     | 44.309     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015391   | 0.015391   | 0.015391   |   0.0 |  0.03
Output  | 3.9394e-05 | 3.9394e-05 | 3.9394e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.27
Other   |            | 0.009487   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4005 ave        4005 max        4005 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:       215194 ave      215194 max      215194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215194
Ave neighs/atom = 53.7985
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.53079822936, Press = 0.786408370790124
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13124.285     -13124.285     -13268.069     -13268.069      278.16035      278.16035      67313.517      67313.517      182.01145      182.01145    
     18000  -13131.056     -13131.056     -13270.008     -13270.008      268.81202      268.81202      67345.253      67345.253     -315.9394      -315.9394     
Loop time of 44.5182 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.941 ns/day, 12.366 hours/ns, 22.463 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.372     | 44.372     | 44.372     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01568    | 0.01568    | 0.01568    |   0.0 |  0.04
Output  | 6.41e-05   | 6.41e-05   | 6.41e-05   |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.27
Other   |            | 0.009697   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4065 ave        4065 max        4065 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:       215180 ave      215180 max      215180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215180
Ave neighs/atom = 53.795
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.479413952535, Press = 1.31681461951251
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13131.056     -13131.056     -13270.008     -13270.008      268.81202      268.81202      67345.253      67345.253     -315.9394      -315.9394     
     19000  -13126.915     -13126.915     -13267.726     -13267.726      272.40716      272.40716      67289.173      67289.173      376.9461       376.9461     
Loop time of 44.4607 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.943 ns/day, 12.350 hours/ns, 22.492 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.315     | 44.315     | 44.315     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01554    | 0.01554    | 0.01554    |   0.0 |  0.03
Output  | 3.7801e-05 | 3.7801e-05 | 3.7801e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.27
Other   |            | 0.009516   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4009 ave        4009 max        4009 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:       215236 ave      215236 max      215236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215236
Ave neighs/atom = 53.809
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.516398686792, Press = 2.48921767143837
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13126.915     -13126.915     -13267.726     -13267.726      272.40716      272.40716      67289.173      67289.173      376.9461       376.9461     
     20000  -13128.762     -13128.762     -13270.894     -13270.894      274.96412      274.96412      67295.645      67295.645      212.58561      212.58561    
Loop time of 44.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.934 ns/day, 12.410 hours/ns, 22.383 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.53      | 44.53      | 44.53      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015603   | 0.015603   | 0.015603   |   0.0 |  0.03
Output  | 3.216e-05  | 3.216e-05  | 3.216e-05  |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.27
Other   |            | 0.009515   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4032 ave        4032 max        4032 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:       215212 ave      215212 max      215212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215212
Ave neighs/atom = 53.803
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.535391273803, Press = -1.38927007911875
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13128.762     -13128.762     -13270.894     -13270.894      274.96412      274.96412      67295.645      67295.645      212.58561      212.58561    
     21000  -13124.085     -13124.085     -13265.419     -13265.419      273.42054      273.42054      67423.222      67423.222     -815.78264     -815.78264    
Loop time of 44.6288 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.397 hours/ns, 22.407 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.482     | 44.482     | 44.482     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015745   | 0.015745   | 0.015745   |   0.0 |  0.04
Output  | 5.1737e-05 | 5.1737e-05 | 5.1737e-05 |   0.0 |  0.00
Modify  | 0.12106    | 0.12106    | 0.12106    |   0.0 |  0.27
Other   |            | 0.009721   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4071 ave        4071 max        4071 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:       215290 ave      215290 max      215290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215290
Ave neighs/atom = 53.8225
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.671392166153, Press = 2.20135937390296
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13124.085     -13124.085     -13265.419     -13265.419      273.42054      273.42054      67423.222      67423.222     -815.78264     -815.78264    
     22000  -13128.443     -13128.443     -13267.897     -13267.897      269.78338      269.78338      67235.628      67235.628      851.90294      851.90294    
Loop time of 44.5488 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.375 hours/ns, 22.447 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.403     | 44.403     | 44.403     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015409   | 0.015409   | 0.015409   |   0.0 |  0.03
Output  | 4.1929e-05 | 4.1929e-05 | 4.1929e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.27
Other   |            | 0.009504   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3995 ave        3995 max        3995 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:       215094 ave      215094 max      215094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215094
Ave neighs/atom = 53.7735
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.754302293306, Press = 1.18311678300754
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13128.443     -13128.443     -13267.897     -13267.897      269.78338      269.78338      67235.628      67235.628      851.90294      851.90294    
     23000  -13123.702     -13123.702     -13264.501     -13264.501      272.38652      272.38652      67385.664      67385.664     -398.97956     -398.97956    
Loop time of 44.5756 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.938 ns/day, 12.382 hours/ns, 22.434 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.43      | 44.43      | 44.43      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015719   | 0.015719   | 0.015719   |   0.0 |  0.04
Output  | 4.3502e-05 | 4.3502e-05 | 4.3502e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.27
Other   |            | 0.009564   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4087 ave        4087 max        4087 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:       215212 ave      215212 max      215212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215212
Ave neighs/atom = 53.803
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.714704539745, Press = 0.0172958125329074
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13123.702     -13123.702     -13264.501     -13264.501      272.38652      272.38652      67385.664      67385.664     -398.97956     -398.97956    
     24000  -13129.466     -13129.466     -13265.846     -13265.846      263.83716      263.83716      67320.973      67320.973      101.57711      101.57711    
Loop time of 44.8852 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.468 hours/ns, 22.279 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    | 44.738     | 44.738     | 44.738     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01562    | 0.01562    | 0.01562    |   0.0 |  0.03
Output  | 3.2712e-05 | 3.2712e-05 | 3.2712e-05 |   0.0 |  0.00
Modify  | 0.12188    | 0.12188    | 0.12188    |   0.0 |  0.27
Other   |            | 0.009565   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4016 ave        4016 max        4016 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:       215104 ave      215104 max      215104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215104
Ave neighs/atom = 53.776
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.681254488275, Press = 1.48826638211484
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13129.466     -13129.466     -13265.846     -13265.846      263.83716      263.83716      67320.973      67320.973      101.57711      101.57711    
     25000  -13124.888     -13124.888     -13266.529     -13266.529      274.01524      274.01524      67318.431      67318.431      174.59866      174.59866    
Loop time of 44.8941 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.925 ns/day, 12.471 hours/ns, 22.275 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    | 44.747     | 44.747     | 44.747     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015755   | 0.015755   | 0.015755   |   0.0 |  0.04
Output  | 4.6317e-05 | 4.6317e-05 | 4.6317e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.27
Other   |            | 0.009593   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4057 ave        4057 max        4057 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:       215198 ave      215198 max      215198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215198
Ave neighs/atom = 53.7995
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.652685989067, Press = 0.466807293178956
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13124.888     -13124.888     -13266.529     -13266.529      274.01524      274.01524      67318.431      67318.431      174.59866      174.59866    
     26000  -13126.728     -13126.728     -13266.371     -13266.371      270.14832      270.14832      67360.062      67360.062     -243.21945     -243.21945    
Loop time of 44.6493 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.935 ns/day, 12.403 hours/ns, 22.397 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    | 44.503     | 44.503     | 44.503     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015732   | 0.015732   | 0.015732   |   0.0 |  0.04
Output  | 4.4614e-05 | 4.4614e-05 | 4.4614e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.27
Other   |            | 0.009551   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4038 ave        4038 max        4038 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:       215158 ave      215158 max      215158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215158
Ave neighs/atom = 53.7895
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.672487061829, Press = 0.364450591921471
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 = 14 14 14
  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) = 4.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13126.728     -13126.728     -13266.371     -13266.371      270.14832      270.14832      67360.062      67360.062     -243.21945     -243.21945    
     27000  -13120.711     -13120.711     -13266.908     -13266.908      282.82765      282.82765      67335.823      67335.823      65.373376      65.373376    
Loop time of 44.6904 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.933 ns/day, 12.414 hours/ns, 22.376 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    | 44.544     | 44.544     | 44.544     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015484   | 0.015484   | 0.015484   |   0.0 |  0.03
Output  | 3.8483e-05 | 3.8483e-05 | 3.8483e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.27
Other   |            | 0.009518   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3989 ave        3989 max        3989 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:       215200 ave      215200 max      215200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215200
Ave neighs/atom = 53.8
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.742215276164, Press = 1.52220224133054
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13120.711     -13120.711     -13266.908     -13266.908      282.82765      282.82765      67335.823      67335.823      65.373376      65.373376    
     28000  -13126.79      -13126.79      -13269.869     -13269.869      276.79477      276.79477      67271.405      67271.405      460.55338      460.55338    
Loop time of 44.5888 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.938 ns/day, 12.386 hours/ns, 22.427 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    | 44.442     | 44.442     | 44.442     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015793   | 0.015793   | 0.015793   |   0.0 |  0.04
Output  | 3.142e-05  | 3.142e-05  | 3.142e-05  |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.27
Other   |            | 0.009604   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4082 ave        4082 max        4082 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:       215224 ave      215224 max      215224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215224
Ave neighs/atom = 53.806
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.806331394512, Press = -0.311354963510164
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13126.79      -13126.79      -13269.869     -13269.869      276.79477      276.79477      67271.405      67271.405      460.55338      460.55338    
     29000  -13122.504     -13122.504     -13265.003     -13265.003      275.67374      275.67374      67445.656      67445.656     -957.97403     -957.97403    
Loop time of 44.6244 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.396 hours/ns, 22.409 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    | 44.478     | 44.478     | 44.478     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015733   | 0.015733   | 0.015733   |   0.0 |  0.04
Output  | 6.1816e-05 | 6.1816e-05 | 6.1816e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.27
Other   |            | 0.009555   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4043 ave        4043 max        4043 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:       215142 ave      215142 max      215142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215142
Ave neighs/atom = 53.7855
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.89733621332, Press = 0.64101435378065
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13122.504     -13122.504     -13265.003     -13265.003      275.67374      275.67374      67445.656      67445.656     -957.97403     -957.97403    
     30000  -13124.09      -13124.09      -13265.661     -13265.661      273.87888      273.87888      67268.278      67268.278      642.11364      642.11364    
Loop time of 44.5058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.941 ns/day, 12.363 hours/ns, 22.469 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    | 44.359     | 44.359     | 44.359     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015599   | 0.015599   | 0.015599   |   0.0 |  0.04
Output  | 4.1388e-05 | 4.1388e-05 | 4.1388e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.27
Other   |            | 0.00947    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4044 ave        4044 max        4044 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:       215162 ave      215162 max      215162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215162
Ave neighs/atom = 53.7905
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.896989906254, Press = 1.2691342544757
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13124.09      -13124.09      -13265.661     -13265.661      273.87888      273.87888      67268.278      67268.278      642.11364      642.11364    
     31000  -13127.389     -13127.389     -13269.059     -13269.059      274.06847      274.06847      67347.387      67347.387     -221.13138     -221.13138    
Loop time of 44.6168 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.394 hours/ns, 22.413 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    | 44.47      | 44.47      | 44.47      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015896   | 0.015896   | 0.015896   |   0.0 |  0.04
Output  | 3.695e-05  | 3.695e-05  | 3.695e-05  |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.27
Other   |            | 0.009443   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4065 ave        4065 max        4065 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:       215194 ave      215194 max      215194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215194
Ave neighs/atom = 53.7985
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.882905906624, Press = -0.0855681670781365
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 = 14 14 14
  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) = 4.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13127.389     -13127.389     -13269.059     -13269.059      274.06847      274.06847      67347.387      67347.387     -221.13138     -221.13138    
     32000  -13124.901     -13124.901     -13266.995     -13266.995      274.88928      274.88928      67344.074      67344.074     -41.972283     -41.972283    
Loop time of 44.6884 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.933 ns/day, 12.413 hours/ns, 22.377 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    | 44.543     | 44.543     | 44.543     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015424   | 0.015424   | 0.015424   |   0.0 |  0.03
Output  | 3.5978e-05 | 3.5978e-05 | 3.5978e-05 |   0.0 |  0.00
Modify  | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.27
Other   |            | 0.009316   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3992 ave        3992 max        3992 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:       215278 ave      215278 max      215278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215278
Ave neighs/atom = 53.8195
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.958720036192, Press = 0.826295909186338
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13124.901     -13124.901     -13266.995     -13266.995      274.88928      274.88928      67344.074      67344.074     -41.972283     -41.972283    
     33000  -13131.302     -13131.302     -13272.14      -13272.14       272.46027      272.46027      67286.713      67286.713      218.8965       218.8965     
Loop time of 44.4916 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.942 ns/day, 12.359 hours/ns, 22.476 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    | 44.345     | 44.345     | 44.345     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015955   | 0.015955   | 0.015955   |   0.0 |  0.04
Output  | 4.0887e-05 | 4.0887e-05 | 4.0887e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.27
Other   |            | 0.009417   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4094 ave        4094 max        4094 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:       215140 ave      215140 max      215140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215140
Ave neighs/atom = 53.785
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.934596618847, Press = 0.35154194977056
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 = 14 14 14
  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) = 4.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13131.302     -13131.302     -13272.14      -13272.14       272.46027      272.46027      67286.713      67286.713      218.8965       218.8965     
     34000  -13125.074     -13125.074     -13264.404     -13264.404      269.54239      269.54239      67379.678      67379.678     -349.49814     -349.49814    
Loop time of 44.7101 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.932 ns/day, 12.419 hours/ns, 22.366 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    | 44.564     | 44.564     | 44.564     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015534   | 0.015534   | 0.015534   |   0.0 |  0.03
Output  | 5.5154e-05 | 5.5154e-05 | 5.5154e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.27
Other   |            | 0.009371   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3989 ave        3989 max        3989 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:       215290 ave      215290 max      215290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215290
Ave neighs/atom = 53.8225
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.898459405065, Press = 0.0445505319385626
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13125.074     -13125.074     -13264.404     -13264.404      269.54239      269.54239      67379.678      67379.678     -349.49814     -349.49814    
     35000  -13130.637     -13130.637     -13269.541     -13269.541      268.71804      268.71804      67279.195      67279.195      373.63692      373.63692    
Loop time of 44.6521 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.935 ns/day, 12.403 hours/ns, 22.395 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    | 44.506     | 44.506     | 44.506     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015758   | 0.015758   | 0.015758   |   0.0 |  0.04
Output  | 5.7568e-05 | 5.7568e-05 | 5.7568e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.27
Other   |            | 0.009471   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4037 ave        4037 max        4037 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:       215106 ave      215106 max      215106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215106
Ave neighs/atom = 53.7765
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.852266294052, Press = 2.29242821162997
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13130.637     -13130.637     -13269.541     -13269.541      268.71804      268.71804      67279.195      67279.195      373.63692      373.63692    
     36000  -13127.97      -13127.97      -13267.321     -13267.321      269.5835       269.5835       67259.613      67259.613      669.40865      669.40865    
Loop time of 44.6718 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.934 ns/day, 12.409 hours/ns, 22.385 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    | 44.524     | 44.524     | 44.524     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015832   | 0.015832   | 0.015832   |   0.0 |  0.04
Output  | 4.5566e-05 | 4.5566e-05 | 4.5566e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.27
Other   |            | 0.009723   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4023 ave        4023 max        4023 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:       215260 ave      215260 max      215260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215260
Ave neighs/atom = 53.815
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.858637786493, Press = -0.524756622139893
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13127.97      -13127.97      -13267.321     -13267.321      269.5835       269.5835       67259.613      67259.613      669.40865      669.40865    
     37000  -13122.292     -13122.292     -13267.686     -13267.686      281.27455      281.27455      67415.967      67415.967     -727.32399     -727.32399    
Loop time of 44.7635 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.930 ns/day, 12.434 hours/ns, 22.340 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 44.616     | 44.616     | 44.616     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016016   | 0.016016   | 0.016016   |   0.0 |  0.04
Output  | 0.00010228 | 0.00010228 | 0.00010228 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.27
Other   |            | 0.00968    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4087 ave        4087 max        4087 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:       215190 ave      215190 max      215190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215190
Ave neighs/atom = 53.7975
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.909716731661, Press = 0.436204989959265
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13122.292     -13122.292     -13267.686     -13267.686      281.27455      281.27455      67415.967      67415.967     -727.32399     -727.32399    
     38000  -13127.584     -13127.584     -13270.081     -13270.081      275.67067      275.67067      67272.434      67272.434      459.63407      459.63407    
Loop time of 45.2632 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.909 ns/day, 12.573 hours/ns, 22.093 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    | 45.114     | 45.114     | 45.114     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015986   | 0.015986   | 0.015986   |   0.0 |  0.04
Output  | 4.6628e-05 | 4.6628e-05 | 4.6628e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.27
Other   |            | 0.009681   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4067 ave        4067 max        4067 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:       215146 ave      215146 max      215146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215146
Ave neighs/atom = 53.7865
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.972160192905, Press = 0.761351796383408
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13127.584     -13127.584     -13270.081     -13270.081      275.67067      275.67067      67272.434      67272.434      459.63407      459.63407    
     39000  -13127.501     -13127.501     -13267.224     -13267.224      270.30436      270.30436      67335.908      67335.908     -43.076614     -43.076614    
Loop time of 44.7023 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.933 ns/day, 12.417 hours/ns, 22.370 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    | 44.555     | 44.555     | 44.555     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015643   | 0.015643   | 0.015643   |   0.0 |  0.03
Output  | 4.6959e-05 | 4.6959e-05 | 4.6959e-05 |   0.0 |  0.00
Modify  | 0.12189    | 0.12189    | 0.12189    |   0.0 |  0.27
Other   |            | 0.009558   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4001 ave        4001 max        4001 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:       215274 ave      215274 max      215274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215274
Ave neighs/atom = 53.8185
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
67331.5991154488

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0