# 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 3.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  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 (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoGrabowskiNeugebauer_2015_NiTi__MO_663355627503_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9611745232 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_663355627503_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17627.791     -17627.791     -17800         -17800          333.15         333.15         43665.961      43665.961      4212.4217      4212.4217    
      1000  -17443.958     -17443.958     -17617.631     -17617.631      335.98316      335.98316      44231.265      44231.265     -1099.1386     -1099.1386    
Loop time of 426.661 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.517 hours/ns, 2.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.62     | 425.62     | 425.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1621     | 0.1621     | 0.1621     |   0.0 |  0.04
Output  | 0.00027442 | 0.00027442 | 0.00027442 |   0.0 |  0.00
Modify  | 0.77143    | 0.77143    | 0.77143    |   0.0 |  0.18
Other   |            | 0.1036     |            |       |  0.02

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

Total # of neighbors = 536000
Ave neighs/atom = 134
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17443.958     -17443.958     -17617.631     -17617.631      335.98316      335.98316      44231.265      44231.265     -1099.1386     -1099.1386    
      2000  -17454.558     -17454.558     -17627.461     -17627.461      334.49271      334.49271      44205.753      44205.753     -961.71047     -961.71047    
Loop time of 407.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.272 hours/ns, 2.452 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 406.76     | 406.76     | 406.76     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16506    | 0.16506    | 0.16506    |   0.0 |  0.04
Output  | 0.00023226 | 0.00023226 | 0.00023226 |   0.0 |  0.00
Modify  | 0.75132    | 0.75132    | 0.75132    |   0.0 |  0.18
Other   |            | 0.1041     |            |       |  0.03

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

Total # of neighbors = 541066
Ave neighs/atom = 135.2665
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17454.558     -17454.558     -17627.461     -17627.461      334.49271      334.49271      44205.753      44205.753     -961.71047     -961.71047    
      3000  -17453.399     -17453.399     -17622.943     -17622.943      327.99346      327.99346      44171.573      44171.573      747.4996       747.4996     
Loop time of 431.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.728 hours/ns, 2.320 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.93     | 429.93     | 429.93     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17275    | 0.17275    | 0.17275    |   0.0 |  0.04
Output  | 0.0002289  | 0.0002289  | 0.0002289  |   0.0 |  0.00
Modify  | 0.81263    | 0.81263    | 0.81263    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.02

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

Total # of neighbors = 540904
Ave neighs/atom = 135.226
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17453.399     -17453.399     -17622.943     -17622.943      327.99346      327.99346      44171.573      44171.573      747.4996       747.4996     
      4000  -17451.167     -17451.167     -17625.231     -17625.231      336.73855      336.73855      44179.489      44179.489      391.43306      391.43306    
Loop time of 396.6 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.167 hours/ns, 2.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 395.62     | 395.62     | 395.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16156    | 0.16156    | 0.16156    |   0.0 |  0.04
Output  | 0.00023472 | 0.00023472 | 0.00023472 |   0.0 |  0.00
Modify  | 0.72051    | 0.72051    | 0.72051    |   0.0 |  0.18
Other   |            | 0.09962    |            |       |  0.03

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

Total # of neighbors = 541244
Ave neighs/atom = 135.311
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17451.167     -17451.167     -17625.231     -17625.231      336.73855      336.73855      44179.489      44179.489      391.43306      391.43306    
      5000  -17456.257     -17456.257     -17628.396     -17628.396      333.0137       333.0137       44193.812      44193.812     -605.82939     -605.82939    
Loop time of 422.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.229 hours/ns, 2.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.95     | 420.95     | 420.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17098    | 0.17098    | 0.17098    |   0.0 |  0.04
Output  | 0.00023015 | 0.00023015 | 0.00023015 |   0.0 |  0.00
Modify  | 0.79812    | 0.79812    | 0.79812    |   0.0 |  0.19
Other   |            | 0.1051     |            |       |  0.02

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

Total # of neighbors = 541244
Ave neighs/atom = 135.311
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 = 331.166240342906, Press = -562.09277475794
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17456.257     -17456.257     -17628.396     -17628.396      333.0137       333.0137       44193.812      44193.812     -605.82939     -605.82939    
      6000  -17450.116     -17450.116     -17623.948     -17623.948      336.2898       336.2898       44234.89       44234.89      -1858.4326     -1858.4326    
Loop time of 421.014 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.948 hours/ns, 2.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 419.91     | 419.91     | 419.91     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16967    | 0.16967    | 0.16967    |   0.0 |  0.04
Output  | 0.0002473  | 0.0002473  | 0.0002473  |   0.0 |  0.00
Modify  | 0.8264     | 0.8264     | 0.8264     |   0.0 |  0.20
Other   |            | 0.1068     |            |       |  0.03

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

Total # of neighbors = 541070
Ave neighs/atom = 135.2675
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 = 332.563823146712, Press = 24.0125029365666
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17450.116     -17450.116     -17623.948     -17623.948      336.2898       336.2898       44234.89       44234.89      -1858.4326     -1858.4326    
      7000  -17456.609     -17456.609     -17632.12      -17632.12       339.53748      339.53748      44120.874      44120.874      2212.4729      2212.4729    
Loop time of 428.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.987 hours/ns, 2.335 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    | 427.24     | 427.24     | 427.24     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17313    | 0.17313    | 0.17313    |   0.0 |  0.04
Output  | 0.00018895 | 0.00018895 | 0.00018895 |   0.0 |  0.00
Modify  | 0.83271    | 0.83271    | 0.83271    |   0.0 |  0.19
Other   |            | 0.1066     |            |       |  0.02

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

Total # of neighbors = 540944
Ave neighs/atom = 135.236
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 = 332.921266065636, Press = 16.8435122651299
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17456.609     -17456.609     -17632.12      -17632.12       339.53748      339.53748      44120.874      44120.874      2212.4729      2212.4729    
      8000  -17451.369     -17451.369     -17626.328     -17626.328      338.46897      338.46897      44173.102      44173.102      492.69197      492.69197    
Loop time of 406.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.910 hours/ns, 2.460 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 405.44     | 405.44     | 405.44     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16253    | 0.16253    | 0.16253    |   0.0 |  0.04
Output  | 0.0001944  | 0.0001944  | 0.0001944  |   0.0 |  0.00
Modify  | 0.77249    | 0.77249    | 0.77249    |   0.0 |  0.19
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 541368
Ave neighs/atom = 135.342
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 = 332.945669836983, Press = -19.6739040661904
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17451.369     -17451.369     -17626.328     -17626.328      338.46897      338.46897      44173.102      44173.102      492.69197      492.69197    
      9000  -17453.692     -17453.692     -17627.651     -17627.651      336.53704      336.53704      44216.726      44216.726     -1386.2904     -1386.2904    
Loop time of 422.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.483 hours/ns, 2.364 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.84     | 421.84     | 421.84     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17391    | 0.17391    | 0.17391    |   0.0 |  0.04
Output  | 0.00019357 | 0.00019357 | 0.00019357 |   0.0 |  0.00
Modify  | 0.81951    | 0.81951    | 0.81951    |   0.0 |  0.19
Other   |            | 0.106      |            |       |  0.03

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

Total # of neighbors = 541140
Ave neighs/atom = 135.285
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 = 332.891820273287, Press = -7.44306692681678
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17453.692     -17453.692     -17627.651     -17627.651      336.53704      336.53704      44216.726      44216.726     -1386.2904     -1386.2904    
     10000  -17454.572     -17454.572     -17626.207     -17626.207      332.038        332.038        44187.125      44187.125     -115.63905     -115.63905    
Loop time of 403.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 111.984 hours/ns, 2.481 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 402.1      | 402.1      | 402.1      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16335    | 0.16335    | 0.16335    |   0.0 |  0.04
Output  | 0.00018882 | 0.00018882 | 0.00018882 |   0.0 |  0.00
Modify  | 0.77433    | 0.77433    | 0.77433    |   0.0 |  0.19
Other   |            | 0.1021     |            |       |  0.03

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

Total # of neighbors = 541010
Ave neighs/atom = 135.2525
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 = 333.001292698682, Press = 1.01199842658141
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17454.572     -17454.572     -17626.207     -17626.207      332.038        332.038        44187.125      44187.125     -115.63905     -115.63905    
     11000  -17449.6       -17449.6       -17621.647     -17621.647      332.83651      332.83651      44160.105      44160.105      1446.34        1446.34      
Loop time of 370.423 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.895 hours/ns, 2.700 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.49     | 369.49     | 369.49     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15462    | 0.15462    | 0.15462    |   0.0 |  0.04
Output  | 0.00019188 | 0.00019188 | 0.00019188 |   0.0 |  0.00
Modify  | 0.6811     | 0.6811     | 0.6811     |   0.0 |  0.18
Other   |            | 0.09485    |            |       |  0.03

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

Total # of neighbors = 541112
Ave neighs/atom = 135.278
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 = 333.28690474752, Press = -5.10651329459272
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17449.6       -17449.6       -17621.647     -17621.647      332.83651      332.83651      44160.105      44160.105      1446.34        1446.34      
     12000  -17451.263     -17451.263     -17623.94      -17623.94       334.05585      334.05585      44227.469      44227.469     -1561.6068     -1561.6068    
Loop time of 397.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.502 hours/ns, 2.514 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 396.79     | 396.79     | 396.79     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16134    | 0.16134    | 0.16134    |   0.0 |  0.04
Output  | 0.0001911  | 0.0001911  | 0.0001911  |   0.0 |  0.00
Modify  | 0.75464    | 0.75464    | 0.75464    |   0.0 |  0.19
Other   |            | 0.09961    |            |       |  0.03

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

Total # of neighbors = 541242
Ave neighs/atom = 135.3105
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 = 333.192104863625, Press = -14.993598006894
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17451.263     -17451.263     -17623.94      -17623.94       334.05585      334.05585      44227.469      44227.469     -1561.6068     -1561.6068    
     13000  -17454.402     -17454.402     -17628.014     -17628.014      335.86344      335.86344      44233.895      44233.895     -2153.1501     -2153.1501    
Loop time of 380.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.820 hours/ns, 2.625 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 379.98     | 379.98     | 379.98     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16151    | 0.16151    | 0.16151    |   0.0 |  0.04
Output  | 0.00026651 | 0.00026651 | 0.00026651 |   0.0 |  0.00
Modify  | 0.71024    | 0.71024    | 0.71024    |   0.0 |  0.19
Other   |            | 0.09651    |            |       |  0.03

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

Total # of neighbors = 541048
Ave neighs/atom = 135.262
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 = 333.286403693413, Press = 2.18591842489032
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17454.402     -17454.402     -17628.014     -17628.014      335.86344      335.86344      44233.895      44233.895     -2153.1501     -2153.1501    
     14000  -17449.296     -17449.296     -17623.095     -17623.095      336.2269       336.2269       44169.541      44169.541      1000.503       1000.503     
Loop time of 370.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.839 hours/ns, 2.701 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.29     | 369.29     | 369.29     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15257    | 0.15257    | 0.15257    |   0.0 |  0.04
Output  | 0.00019433 | 0.00019433 | 0.00019433 |   0.0 |  0.00
Modify  | 0.68131    | 0.68131    | 0.68131    |   0.0 |  0.18
Other   |            | 0.09566    |            |       |  0.03

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

Total # of neighbors = 540868
Ave neighs/atom = 135.217
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 = 333.292180918401, Press = 1.67712847309824
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17449.296     -17449.296     -17623.095     -17623.095      336.2269       336.2269       44169.541      44169.541      1000.503       1000.503     
     15000  -17453.243     -17453.243     -17625.877     -17625.877      333.97164      333.97164      44172.384      44172.384      577.48429      577.48429    
Loop time of 407.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.254 hours/ns, 2.453 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 406.66     | 406.66     | 406.66     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16725    | 0.16725    | 0.16725    |   0.0 |  0.04
Output  | 0.00019142 | 0.00019142 | 0.00019142 |   0.0 |  0.00
Modify  | 0.7824     | 0.7824     | 0.7824     |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.03

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

Total # of neighbors = 541262
Ave neighs/atom = 135.3155
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 = 333.476998892037, Press = -4.62310322758973
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17453.243     -17453.243     -17625.877     -17625.877      333.97164      333.97164      44172.384      44172.384      577.48429      577.48429    
     16000  -17446.643     -17446.643     -17623.539     -17623.539      342.21677      342.21677      44229.502      44229.502     -1476.7843     -1476.7843    
Loop time of 422.283 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.301 hours/ns, 2.368 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    | 421.18     | 421.18     | 421.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1708     | 0.1708     | 0.1708     |   0.0 |  0.04
Output  | 0.00018928 | 0.00018928 | 0.00018928 |   0.0 |  0.00
Modify  | 0.82286    | 0.82286    | 0.82286    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

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

Total # of neighbors = 541260
Ave neighs/atom = 135.315
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 = 333.534302776399, Press = -2.24764246089051
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17446.643     -17446.643     -17623.539     -17623.539      342.21677      342.21677      44229.502      44229.502     -1476.7843     -1476.7843    
     17000  -17451.773     -17451.773     -17624.988     -17624.988      335.09642      335.09642      44187.341      44187.341      99.563688      99.563688    
Loop time of 431.558 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.877 hours/ns, 2.317 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    | 430.43     | 430.43     | 430.43     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17469    | 0.17469    | 0.17469    |   0.0 |  0.04
Output  | 0.00024742 | 0.00024742 | 0.00024742 |   0.0 |  0.00
Modify  | 0.84368    | 0.84368    | 0.84368    |   0.0 |  0.20
Other   |            | 0.1082     |            |       |  0.03

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

Total # of neighbors = 541112
Ave neighs/atom = 135.278
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 = 333.631420822245, Press = 4.78620527793976
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17451.773     -17451.773     -17624.988     -17624.988      335.09642      335.09642      44187.341      44187.341      99.563688      99.563688    
     18000  -17452.997     -17452.997     -17627.083     -17627.083      336.78141      336.78141      44108.268      44108.268      3147.8081      3147.8081    
Loop time of 413.224 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.784 hours/ns, 2.420 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 412.16     | 412.16     | 412.16     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16645    | 0.16645    | 0.16645    |   0.0 |  0.04
Output  | 0.00022878 | 0.00022878 | 0.00022878 |   0.0 |  0.00
Modify  | 0.79117    | 0.79117    | 0.79117    |   0.0 |  0.19
Other   |            | 0.104      |            |       |  0.03

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

Total # of neighbors = 541234
Ave neighs/atom = 135.3085
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 = 333.556808683023, Press = -3.27671124498807
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17452.997     -17452.997     -17627.083     -17627.083      336.78141      336.78141      44108.268      44108.268      3147.8081      3147.8081    
     19000  -17452.858     -17452.858     -17625.444     -17625.444      333.87788      333.87788      44211.496      44211.496     -945.88477     -945.88477    
Loop time of 427.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.816 hours/ns, 2.338 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 426.62     | 426.62     | 426.62     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17418    | 0.17418    | 0.17418    |   0.0 |  0.04
Output  | 0.00024678 | 0.00024678 | 0.00024678 |   0.0 |  0.00
Modify  | 0.84007    | 0.84007    | 0.84007    |   0.0 |  0.20
Other   |            | 0.1073     |            |       |  0.03

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

Total # of neighbors = 541460
Ave neighs/atom = 135.365
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 = 333.545990203271, Press = -3.81933448679832
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17452.858     -17452.858     -17625.444     -17625.444      333.87788      333.87788      44211.496      44211.496     -945.88477     -945.88477    
     20000  -17451.825     -17451.825     -17622.931     -17622.931      331.01642      331.01642      44194.188      44194.188     -51.236911     -51.236911    
Loop time of 422.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.224 hours/ns, 2.370 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.91     | 420.91     | 420.91     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1702     | 0.1702     | 0.1702     |   0.0 |  0.04
Output  | 0.00019243 | 0.00019243 | 0.00019243 |   0.0 |  0.00
Modify  | 0.81666    | 0.81666    | 0.81666    |   0.0 |  0.19
Other   |            | 0.1057     |            |       |  0.03

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

Total # of neighbors = 541114
Ave neighs/atom = 135.2785
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 = 333.482005448406, Press = 0.892620399809068
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17451.825     -17451.825     -17622.931     -17622.931      331.01642      331.01642      44194.188      44194.188     -51.236911     -51.236911    
     21000  -17453.092     -17453.092     -17626.027     -17626.027      334.55419      334.55419      44152.362      44152.362      1410.389       1410.389     
Loop time of 405.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.669 hours/ns, 2.465 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 404.57     | 404.57     | 404.57     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16299    | 0.16299    | 0.16299    |   0.0 |  0.04
Output  | 0.00025137 | 0.00025137 | 0.00025137 |   0.0 |  0.00
Modify  | 0.77089    | 0.77089    | 0.77089    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.03

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

Total # of neighbors = 541154
Ave neighs/atom = 135.2885
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 = 333.387428950818, Press = -0.619521428501339
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17453.092     -17453.092     -17626.027     -17626.027      334.55419      334.55419      44152.362      44152.362      1410.389       1410.389     
     22000  -17448.628     -17448.628     -17620.671     -17620.671      332.82701      332.82701      44193.542      44193.542      239.46483      239.46483    
Loop time of 407.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.069 hours/ns, 2.457 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 406.01     | 406.01     | 406.01     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.163      | 0.163      | 0.163      |   0.0 |  0.04
Output  | 0.0002641  | 0.0002641  | 0.0002641  |   0.0 |  0.00
Modify  | 0.76901    | 0.76901    | 0.76901    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.03

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

Total # of neighbors = 541188
Ave neighs/atom = 135.297
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 = 333.352688840075, Press = -4.62801898964738
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17448.628     -17448.628     -17620.671     -17620.671      332.82701      332.82701      44193.542      44193.542      239.46483      239.46483    
     23000  -17453.903     -17453.903     -17624.544     -17624.544      330.11645      330.11645      44285.728      44285.728     -3964.5853     -3964.5853    
Loop time of 430.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.643 hours/ns, 2.322 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.6      | 429.6      | 429.6      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17284    | 0.17284    | 0.17284    |   0.0 |  0.04
Output  | 0.00026369 | 0.00026369 | 0.00026369 |   0.0 |  0.00
Modify  | 0.8357     | 0.8357     | 0.8357     |   0.0 |  0.19
Other   |            | 0.1066     |            |       |  0.02

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

Total # of neighbors = 541178
Ave neighs/atom = 135.2945
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 = 333.350375394008, Press = 0.519131214032064
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17453.903     -17453.903     -17624.544     -17624.544      330.11645      330.11645      44285.728      44285.728     -3964.5853     -3964.5853    
     24000  -17450.831     -17450.831     -17626.474     -17626.474      339.79227      339.79227      44167.978      44167.978      768.41087      768.41087    
Loop time of 428.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.117 hours/ns, 2.332 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 427.7      | 427.7      | 427.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17418    | 0.17418    | 0.17418    |   0.0 |  0.04
Output  | 0.00028916 | 0.00028916 | 0.00028916 |   0.0 |  0.00
Modify  | 0.8381     | 0.8381     | 0.8381     |   0.0 |  0.20
Other   |            | 0.1072     |            |       |  0.02

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

Total # of neighbors = 540830
Ave neighs/atom = 135.2075
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 = 333.285995187702, Press = 2.59271385651725
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17450.831     -17450.831     -17626.474     -17626.474      339.79227      339.79227      44167.978      44167.978      768.41087      768.41087    
     25000  -17459.204     -17459.204     -17630.601     -17630.601      331.57874      331.57874      44145.636      44145.636      1086.2836      1086.2836    
Loop time of 413.229 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.786 hours/ns, 2.420 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 412.15     | 412.15     | 412.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16699    | 0.16699    | 0.16699    |   0.0 |  0.04
Output  | 0.00023782 | 0.00023782 | 0.00023782 |   0.0 |  0.00
Modify  | 0.80311    | 0.80311    | 0.80311    |   0.0 |  0.19
Other   |            | 0.1043     |            |       |  0.03

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

Total # of neighbors = 541306
Ave neighs/atom = 135.3265
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 = 333.19545369118, Press = -1.44642137188103
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17459.204     -17459.204     -17630.601     -17630.601      331.57874      331.57874      44145.636      44145.636      1086.2836      1086.2836    
     26000  -17451.866     -17451.866     -17626.775     -17626.775      338.37308      338.37308      44214.735      44214.735     -1272.3807     -1272.3807    
Loop time of 382.804 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.334 hours/ns, 2.612 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.83     | 381.83     | 381.83     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15823    | 0.15823    | 0.15823    |   0.0 |  0.04
Output  | 0.00019076 | 0.00019076 | 0.00019076 |   0.0 |  0.00
Modify  | 0.71493    | 0.71493    | 0.71493    |   0.0 |  0.19
Other   |            | 0.09847    |            |       |  0.03

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

Total # of neighbors = 541342
Ave neighs/atom = 135.3355
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 = 333.153815757969, Press = -2.22507813196819
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17451.866     -17451.866     -17626.775     -17626.775      338.37308      338.37308      44214.735      44214.735     -1272.3807     -1272.3807    
     27000  -17446.686     -17446.686     -17624.92      -17624.92       344.80533      344.80533      44217.424      44217.424     -1097.4721     -1097.4721    
Loop time of 374.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.981 hours/ns, 2.671 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.38     | 373.38     | 373.38     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15976    | 0.15976    | 0.15976    |   0.0 |  0.04
Output  | 0.0001929  | 0.0001929  | 0.0001929  |   0.0 |  0.00
Modify  | 0.69485    | 0.69485    | 0.69485    |   0.0 |  0.19
Other   |            | 0.09474    |            |       |  0.03

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

Total # of neighbors = 541100
Ave neighs/atom = 135.275
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 = 333.137309822351, Press = 0.320397033018416
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17446.686     -17446.686     -17624.92      -17624.92       344.80533      344.80533      44217.424      44217.424     -1097.4721     -1097.4721    
     28000  -17453.939     -17453.939     -17627.945     -17627.945      336.6271       336.6271       44138.278      44138.278      1808.5297      1808.5297    
Loop time of 430.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.639 hours/ns, 2.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.59     | 429.59     | 429.59     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1723     | 0.1723     | 0.1723     |   0.0 |  0.04
Output  | 0.00019807 | 0.00019807 | 0.00019807 |   0.0 |  0.00
Modify  | 0.83432    | 0.83432    | 0.83432    |   0.0 |  0.19
Other   |            | 0.1084     |            |       |  0.03

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

Total # of neighbors = 541020
Ave neighs/atom = 135.255
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 = 333.204084322349, Press = 0.218511153711237
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17453.939     -17453.939     -17627.945     -17627.945      336.6271       336.6271       44138.278      44138.278      1808.5297      1808.5297    
     29000  -17447.385     -17447.385     -17620.354     -17620.354      334.6195       334.6195       44195.204      44195.204      167.2185       167.2185     
Loop time of 432.932 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.259 hours/ns, 2.310 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    | 431.79     | 431.79     | 431.79     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18395    | 0.18395    | 0.18395    |   0.0 |  0.04
Output  | 0.00028382 | 0.00028382 | 0.00028382 |   0.0 |  0.00
Modify  | 0.85043    | 0.85043    | 0.85043    |   0.0 |  0.20
Other   |            | 0.1073     |            |       |  0.02

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

Total # of neighbors = 541484
Ave neighs/atom = 135.371
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 = 333.282554379381, Press = -4.68761288922627
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17447.385     -17447.385     -17620.354     -17620.354      334.6195       334.6195       44195.204      44195.204      167.2185       167.2185     
     30000  -17451.21      -17451.21      -17624.802     -17624.802      335.82642      335.82642      44242.109      44242.109     -2255.3799     -2255.3799    
Loop time of 415.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.382 hours/ns, 2.407 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 414.3      | 414.3      | 414.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17163    | 0.17163    | 0.17163    |   0.0 |  0.04
Output  | 0.00018891 | 0.00018891 | 0.00018891 |   0.0 |  0.00
Modify  | 0.79718    | 0.79718    | 0.79718    |   0.0 |  0.19
Other   |            | 0.1039     |            |       |  0.03

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

Total # of neighbors = 541188
Ave neighs/atom = 135.297
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
44187.0174128328

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0