# 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.5090000331401834*${_u_distance}
variable latticeconst_converted equal 3.5090000331401834*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.50900003314018
Lattice spacing in x,y,z = 3.509 3.509 3.509
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.09 35.09 35.09)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.09 35.09 35.09)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_001
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43206.6024531732 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_971738391444_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3219.0848     -3219.0848     -3300          -3300           313.15         313.15         43206.602      43206.602      2000.3136      2000.3136    
      1000  -3190.116      -3190.116      -3270.244      -3270.244       310.10329      310.10329      47301.932      47301.932      409.20944      409.20944    
Loop time of 17.1996 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.023 ns/day, 4.778 hours/ns, 58.141 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.994     | 16.994     | 16.994     |   0.0 | 98.81
Neigh   | 0.12494    | 0.12494    | 0.12494    |   0.0 |  0.73
Comm    | 0.013695   | 0.013695   | 0.013695   |   0.0 |  0.08
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.061239   | 0.061239   | 0.061239   |   0.0 |  0.36
Other   |            | 0.005112   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3266 ave        3266 max        3266 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:       119356 ave      119356 max      119356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119356
Ave neighs/atom = 59.678
Neighbor list builds = 24
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3190.116      -3190.116      -3270.244      -3270.244       310.10329      310.10329      47301.932      47301.932      409.20944      409.20944    
      2000  -3190.6388     -3190.6388     -3272.6192     -3272.6192      317.27259      317.27259      47610.521      47610.521     -399.27459     -399.27459    
Loop time of 17.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.067 ns/day, 4.736 hours/ns, 58.648 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.854     | 16.854     | 16.854     |   0.0 | 98.85
Neigh   | 0.11831    | 0.11831    | 0.11831    |   0.0 |  0.69
Comm    | 0.013688   | 0.013688   | 0.013688   |   0.0 |  0.08
Output  | 6.7116e-05 | 6.7116e-05 | 6.7116e-05 |   0.0 |  0.00
Modify  | 0.059755   | 0.059755   | 0.059755   |   0.0 |  0.35
Other   |            | 0.004875   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 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:       118944 ave      118944 max      118944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118944
Ave neighs/atom = 59.472
Neighbor list builds = 23
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3190.6388     -3190.6388     -3272.6192     -3272.6192      317.27259      317.27259      47610.521      47610.521     -399.27459     -399.27459    
      3000  -3189.9144     -3189.9144     -3271.6144     -3271.6144      316.18745      316.18745      47460.75       47460.75       74.04288       74.04288     
Loop time of 17.0237 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.075 ns/day, 4.729 hours/ns, 58.742 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.826     | 16.826     | 16.826     |   0.0 | 98.84
Neigh   | 0.11992    | 0.11992    | 0.11992    |   0.0 |  0.70
Comm    | 0.013616   | 0.013616   | 0.013616   |   0.0 |  0.08
Output  | 4.6186e-05 | 4.6186e-05 | 4.6186e-05 |   0.0 |  0.00
Modify  | 0.059581   | 0.059581   | 0.059581   |   0.0 |  0.35
Other   |            | 0.004824   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3268 ave        3268 max        3268 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:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 24
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3189.9144     -3189.9144     -3271.6144     -3271.6144      316.18745      316.18745      47460.75       47460.75       74.04288       74.04288     
      4000  -3195.8289     -3195.8289     -3274.0336     -3274.0336      302.66021      302.66021      47295.679      47295.679      129.80117      129.80117    
Loop time of 17.0544 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.066 ns/day, 4.737 hours/ns, 58.636 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.861     | 16.861     | 16.861     |   0.0 | 98.87
Neigh   | 0.11545    | 0.11545    | 0.11545    |   0.0 |  0.68
Comm    | 0.013612   | 0.013612   | 0.013612   |   0.0 |  0.08
Output  | 4.8942e-05 | 4.8942e-05 | 4.8942e-05 |   0.0 |  0.00
Modify  | 0.05946    | 0.05946    | 0.05946    |   0.0 |  0.35
Other   |            | 0.004859   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3269 ave        3269 max        3269 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:       119312 ave      119312 max      119312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119312
Ave neighs/atom = 59.656
Neighbor list builds = 23
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3195.8289     -3195.8289     -3274.0336     -3274.0336      302.66021      302.66021      47295.679      47295.679      129.80117      129.80117    
      5000  -3192.6422     -3192.6422     -3273.4465     -3273.4465      312.72103      312.72103      47313.315      47313.315      188.7191       188.7191     
Loop time of 17.0428 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.070 ns/day, 4.734 hours/ns, 58.676 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.844     | 16.844     | 16.844     |   0.0 | 98.83
Neigh   | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.71
Comm    | 0.013694   | 0.013694   | 0.013694   |   0.0 |  0.08
Output  | 3.0498e-05 | 3.0498e-05 | 3.0498e-05 |   0.0 |  0.00
Modify  | 0.059609   | 0.059609   | 0.059609   |   0.0 |  0.35
Other   |            | 0.004836   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 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:       119440 ave      119440 max      119440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119440
Ave neighs/atom = 59.72
Neighbor list builds = 24
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 = 311.251874199594, Press = 55.157419941849
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3192.6422     -3192.6422     -3273.4465     -3273.4465      312.72103      312.72103      47313.315      47313.315      188.7191       188.7191     
      6000  -3191.5565     -3191.5565     -3272.0891     -3272.0891      311.66953      311.66953      47326.737      47326.737      217.55046      217.55046    
Loop time of 17.0165 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.077 ns/day, 4.727 hours/ns, 58.767 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.819     | 16.819     | 16.819     |   0.0 | 98.84
Neigh   | 0.11717    | 0.11717    | 0.11717    |   0.0 |  0.69
Comm    | 0.013717   | 0.013717   | 0.013717   |   0.0 |  0.08
Output  | 2.3664e-05 | 2.3664e-05 | 2.3664e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.36
Other   |            | 0.004891   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3313 ave        3313 max        3313 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:       119234 ave      119234 max      119234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119234
Ave neighs/atom = 59.617
Neighbor list builds = 23
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 = 313.912948644454, Press = 37.0393400108451
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3191.5565     -3191.5565     -3272.0891     -3272.0891      311.66953      311.66953      47326.737      47326.737      217.55046      217.55046    
      7000  -3190.2809     -3190.2809     -3270.5983     -3270.5983      310.83671      310.83671      47597.879      47597.879     -199.98306     -199.98306    
Loop time of 16.9915 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.085 ns/day, 4.720 hours/ns, 58.853 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.793     | 16.793     | 16.793     |   0.0 | 98.83
Neigh   | 0.11778    | 0.11778    | 0.11778    |   0.0 |  0.69
Comm    | 0.013636   | 0.013636   | 0.013636   |   0.0 |  0.08
Output  | 2.4306e-05 | 2.4306e-05 | 2.4306e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.36
Other   |            | 0.004889   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3277 ave        3277 max        3277 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:       118846 ave      118846 max      118846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118846
Ave neighs/atom = 59.423
Neighbor list builds = 23
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 = 313.711540481674, Press = 23.9519040019093
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3190.2809     -3190.2809     -3270.5983     -3270.5983      310.83671      310.83671      47597.879      47597.879     -199.98306     -199.98306    
      8000  -3193.2361     -3193.2361     -3272.7682     -3272.7682      307.79712      307.79712      47664.133      47664.133     -494.48517     -494.48517    
Loop time of 17.0705 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.061 ns/day, 4.742 hours/ns, 58.581 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.873     | 16.873     | 16.873     |   0.0 | 98.84
Neigh   | 0.11712    | 0.11712    | 0.11712    |   0.0 |  0.69
Comm    | 0.013674   | 0.013674   | 0.013674   |   0.0 |  0.08
Output  | 2.3925e-05 | 2.3925e-05 | 2.3925e-05 |   0.0 |  0.00
Modify  | 0.061774   | 0.061774   | 0.061774   |   0.0 |  0.36
Other   |            | 0.004877   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3251 ave        3251 max        3251 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:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 23
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 = 312.858243224631, Press = 17.8337228220632
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3193.2361     -3193.2361     -3272.7682     -3272.7682      307.79712      307.79712      47664.133      47664.133     -494.48517     -494.48517    
      9000  -3195.1543     -3195.1543     -3273.3131     -3273.3131      302.48277      302.48277      47492.994      47492.994     -195.56586     -195.56586    
Loop time of 17.0556 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.066 ns/day, 4.738 hours/ns, 58.632 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.853     | 16.853     | 16.853     |   0.0 | 98.81
Neigh   | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.72
Comm    | 0.013638   | 0.013638   | 0.013638   |   0.0 |  0.08
Output  | 3.4214e-05 | 3.4214e-05 | 3.4214e-05 |   0.0 |  0.00
Modify  | 0.061792   | 0.061792   | 0.061792   |   0.0 |  0.36
Other   |            | 0.00485    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3310 ave        3310 max        3310 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:       119092 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546
Neighbor list builds = 24
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 = 312.567222102296, Press = 1.05646187091624
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3195.1543     -3195.1543     -3273.3131     -3273.3131      302.48277      302.48277      47492.994      47492.994     -195.56586     -195.56586    
     10000  -3190.8234     -3190.8234     -3273.9621     -3273.9621      321.75537      321.75537      47427.393      47427.393      57.499955      57.499955    
Loop time of 17.0262 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.075 ns/day, 4.730 hours/ns, 58.733 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.824     | 16.824     | 16.824     |   0.0 | 98.81
Neigh   | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.71
Comm    | 0.013743   | 0.013743   | 0.013743   |   0.0 |  0.08
Output  | 2.2903e-05 | 2.2903e-05 | 2.2903e-05 |   0.0 |  0.00
Modify  | 0.061719   | 0.061719   | 0.061719   |   0.0 |  0.36
Other   |            | 0.004852   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3345 ave        3345 max        3345 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:       119416 ave      119416 max      119416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119416
Ave neighs/atom = 59.708
Neighbor list builds = 24
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 = 312.747848054188, Press = 5.09751309483904
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3190.8234     -3190.8234     -3273.9621     -3273.9621      321.75537      321.75537      47427.393      47427.393      57.499955      57.499955    
     11000  -3191.4728     -3191.4728     -3272.1778     -3272.1778      312.33677      312.33677      47419.248      47419.248      9.2925608      9.2925608    
Loop time of 17.0323 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.073 ns/day, 4.731 hours/ns, 58.712 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.831     | 16.831     | 16.831     |   0.0 | 98.82
Neigh   | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.71
Comm    | 0.013822   | 0.013822   | 0.013822   |   0.0 |  0.08
Output  | 2.4886e-05 | 2.4886e-05 | 2.4886e-05 |   0.0 |  0.00
Modify  | 0.061651   | 0.061651   | 0.061651   |   0.0 |  0.36
Other   |            | 0.004904   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3296 ave        3296 max        3296 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:       119162 ave      119162 max      119162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119162
Ave neighs/atom = 59.581
Neighbor list builds = 24
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 = 312.545500577286, Press = 4.83265176147092
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3191.4728     -3191.4728     -3272.1778     -3272.1778      312.33677      312.33677      47419.248      47419.248      9.2925608      9.2925608    
     12000  -3193.1502     -3193.1502     -3272.8034     -3272.8034      308.26626      308.26626      47418.171      47418.171      135.34205      135.34205    
Loop time of 17.058 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.065 ns/day, 4.738 hours/ns, 58.624 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.856     | 16.856     | 16.856     |   0.0 | 98.82
Neigh   | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.71
Comm    | 0.013748   | 0.013748   | 0.013748   |   0.0 |  0.08
Output  | 2.3755e-05 | 2.3755e-05 | 2.3755e-05 |   0.0 |  0.00
Modify  | 0.061648   | 0.061648   | 0.061648   |   0.0 |  0.36
Other   |            | 0.004854   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 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:       119166 ave      119166 max      119166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119166
Ave neighs/atom = 59.583
Neighbor list builds = 24
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 = 312.742719120782, Press = 4.9314667501151
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3193.1502     -3193.1502     -3272.8034     -3272.8034      308.26626      308.26626      47418.171      47418.171      135.34205      135.34205    
     13000  -3192.103      -3192.103      -3272.9611     -3272.9611      312.92925      312.92925      47383.5        47383.5        165.7486       165.7486     
Loop time of 16.9751 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.090 ns/day, 4.715 hours/ns, 58.910 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.779     | 16.779     | 16.779     |   0.0 | 98.84
Neigh   | 0.11627    | 0.11627    | 0.11627    |   0.0 |  0.68
Comm    | 0.013701   | 0.013701   | 0.013701   |   0.0 |  0.08
Output  | 3.5727e-05 | 3.5727e-05 | 3.5727e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.36
Other   |            | 0.004873   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 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:       119122 ave      119122 max      119122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119122
Ave neighs/atom = 59.561
Neighbor list builds = 23
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 = 312.729949836294, Press = 5.92430576203409
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3192.103      -3192.103      -3272.9611     -3272.9611      312.92925      312.92925      47383.5        47383.5        165.7486       165.7486     
     14000  -3192.0111     -3192.0111     -3272.7032     -3272.7032      312.28675      312.28675      47751.726      47751.726     -497.52115     -497.52115    
Loop time of 17.0487 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.068 ns/day, 4.736 hours/ns, 58.655 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.847     | 16.847     | 16.847     |   0.0 | 98.82
Neigh   | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.71
Comm    | 0.013697   | 0.013697   | 0.013697   |   0.0 |  0.08
Output  | 8.1513e-05 | 8.1513e-05 | 8.1513e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.36
Other   |            | 0.004855   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3301 ave        3301 max        3301 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:       118744 ave      118744 max      118744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118744
Ave neighs/atom = 59.372
Neighbor list builds = 24
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 = 312.776891600134, Press = 9.57993773162759
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3192.0111     -3192.0111     -3272.7032     -3272.7032      312.28675      312.28675      47751.726      47751.726     -497.52115     -497.52115    
     15000  -3192.7914     -3192.7914     -3272.636      -3272.636       309.00666      309.00666      47540.614      47540.614     -296.68939     -296.68939    
Loop time of 17.0274 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.074 ns/day, 4.730 hours/ns, 58.729 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.826     | 16.826     | 16.826     |   0.0 | 98.82
Neigh   | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.71
Comm    | 0.013672   | 0.013672   | 0.013672   |   0.0 |  0.08
Output  | 2.4466e-05 | 2.4466e-05 | 2.4466e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.36
Other   |            | 0.004852   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3339 ave        3339 max        3339 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:       119140 ave      119140 max      119140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119140
Ave neighs/atom = 59.57
Neighbor list builds = 24
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 = 312.816769237837, Press = 2.48355467661123
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3192.7914     -3192.7914     -3272.636      -3272.636       309.00666      309.00666      47540.614      47540.614     -296.68939     -296.68939    
     16000  -3191.1028     -3191.1028     -3274.5058     -3274.5058      322.77813      322.77813      47460.649      47460.649     -31.635128     -31.635128    
Loop time of 17.0699 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.062 ns/day, 4.742 hours/ns, 58.583 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.873     | 16.873     | 16.873     |   0.0 | 98.84
Neigh   | 0.11683    | 0.11683    | 0.11683    |   0.0 |  0.68
Comm    | 0.013719   | 0.013719   | 0.013719   |   0.0 |  0.08
Output  | 3.4395e-05 | 3.4395e-05 | 3.4395e-05 |   0.0 |  0.00
Modify  | 0.061797   | 0.061797   | 0.061797   |   0.0 |  0.36
Other   |            | 0.004878   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 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:       119250 ave      119250 max      119250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119250
Ave neighs/atom = 59.625
Neighbor list builds = 23
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 = 312.526279463833, Press = 1.67945535903077
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3191.1028     -3191.1028     -3274.5058     -3274.5058      322.77813      322.77813      47460.649      47460.649     -31.635128     -31.635128    
     17000  -3186.5237     -3186.5237     -3270.18       -3270.18        323.75847      323.75847      47473.091      47473.091      161.26761      161.26761    
Loop time of 17.0768 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.060 ns/day, 4.744 hours/ns, 58.559 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.875     | 16.875     | 16.875     |   0.0 | 98.82
Neigh   | 0.12181    | 0.12181    | 0.12181    |   0.0 |  0.71
Comm    | 0.013728   | 0.013728   | 0.013728   |   0.0 |  0.08
Output  | 2.4386e-05 | 2.4386e-05 | 2.4386e-05 |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.36
Other   |            | 0.004868   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3290 ave        3290 max        3290 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:       119108 ave      119108 max      119108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119108
Ave neighs/atom = 59.554
Neighbor list builds = 24
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 = 312.564362604291, Press = 0.573786180486642
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3186.5237     -3186.5237     -3270.18       -3270.18        323.75847      323.75847      47473.091      47473.091      161.26761      161.26761    
     18000  -3192.3121     -3192.3121     -3273.6894     -3273.6894      314.93836      314.93836      47279.004      47279.004      481.39132      481.39132    
Loop time of 17.0558 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.066 ns/day, 4.738 hours/ns, 58.631 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.86      | 16.86      | 16.86      |   0.0 | 98.85
Neigh   | 0.11542    | 0.11542    | 0.11542    |   0.0 |  0.68
Comm    | 0.013611   | 0.013611   | 0.013611   |   0.0 |  0.08
Output  | 2.4336e-05 | 2.4336e-05 | 2.4336e-05 |   0.0 |  0.00
Modify  | 0.06174    | 0.06174    | 0.06174    |   0.0 |  0.36
Other   |            | 0.004854   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3297 ave        3297 max        3297 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:       119304 ave      119304 max      119304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119304
Ave neighs/atom = 59.652
Neighbor list builds = 23
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 = 312.711582511406, Press = 0.557736331359371
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3192.3121     -3192.3121     -3273.6894     -3273.6894      314.93836      314.93836      47279.004      47279.004      481.39132      481.39132    
     19000  -3196.1395     -3196.1395     -3276.0754     -3276.0754      309.35997      309.35997      47265.659      47265.659      480.94571      480.94571    
Loop time of 17.1212 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.046 ns/day, 4.756 hours/ns, 58.407 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.921     | 16.921     | 16.921     |   0.0 | 98.83
Neigh   | 0.12006    | 0.12006    | 0.12006    |   0.0 |  0.70
Comm    | 0.013736   | 0.013736   | 0.013736   |   0.0 |  0.08
Output  | 2.5668e-05 | 2.5668e-05 | 2.5668e-05 |   0.0 |  0.00
Modify  | 0.061703   | 0.061703   | 0.061703   |   0.0 |  0.36
Other   |            | 0.004861   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3322 ave        3322 max        3322 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:       119582 ave      119582 max      119582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119582
Ave neighs/atom = 59.791
Neighbor list builds = 24
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 = 312.798682852285, Press = 2.27893380978665
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3196.1395     -3196.1395     -3276.0754     -3276.0754      309.35997      309.35997      47265.659      47265.659      480.94571      480.94571    
     20000  -3194.1449     -3194.1449     -3276.4029     -3276.4029      318.34701      318.34701      47491.327      47491.327      22.44936       22.44936     
Loop time of 17.2534 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.008 ns/day, 4.793 hours/ns, 57.959 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.058     | 17.058     | 17.058     |   0.0 | 98.87
Neigh   | 0.11458    | 0.11458    | 0.11458    |   0.0 |  0.66
Comm    | 0.013742   | 0.013742   | 0.013742   |   0.0 |  0.08
Output  | 3.5246e-05 | 3.5246e-05 | 3.5246e-05 |   0.0 |  0.00
Modify  | 0.06174    | 0.06174    | 0.06174    |   0.0 |  0.36
Other   |            | 0.004883   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3329 ave        3329 max        3329 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:       119134 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567
Neighbor list builds = 23
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 = 312.907139190745, Press = 1.77053469664079
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3194.1449     -3194.1449     -3276.4029     -3276.4029      318.34701      318.34701      47491.327      47491.327      22.44936       22.44936     
     21000  -3195.97       -3195.97       -3277.4506     -3277.4506      315.33861      315.33861      47420.548      47420.548      68.949281      68.949281    
Loop time of 17.2096 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.020 ns/day, 4.780 hours/ns, 58.107 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.015     | 17.015     | 17.015     |   0.0 | 98.87
Neigh   | 0.1146     | 0.1146     | 0.1146     |   0.0 |  0.67
Comm    | 0.013598   | 0.013598   | 0.013598   |   0.0 |  0.08
Output  | 2.4396e-05 | 2.4396e-05 | 2.4396e-05 |   0.0 |  0.00
Modify  | 0.061665   | 0.061665   | 0.061665   |   0.0 |  0.36
Other   |            | 0.004884   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3311 ave        3311 max        3311 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:       119190 ave      119190 max      119190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119190
Ave neighs/atom = 59.595
Neighbor list builds = 23
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 = 312.983112347368, Press = 3.30653840982065
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3195.97       -3195.97       -3277.4506     -3277.4506      315.33861      315.33861      47420.548      47420.548      68.949281      68.949281    
     22000  -3197.8144     -3197.8144     -3275.9364     -3275.9364      302.34025      302.34025      47454.15       47454.15       12.210266      12.210266    
Loop time of 17.2039 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.022 ns/day, 4.779 hours/ns, 58.126 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.009     | 17.009     | 17.009     |   0.0 | 98.87
Neigh   | 0.11475    | 0.11475    | 0.11475    |   0.0 |  0.67
Comm    | 0.013672   | 0.013672   | 0.013672   |   0.0 |  0.08
Output  | 2.4897e-05 | 2.4897e-05 | 2.4897e-05 |   0.0 |  0.00
Modify  | 0.061697   | 0.061697   | 0.061697   |   0.0 |  0.36
Other   |            | 0.004879   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3344 ave        3344 max        3344 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:       119128 ave      119128 max      119128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119128
Ave neighs/atom = 59.564
Neighbor list builds = 23
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 = 313.003969157961, Press = 2.0094737178441
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3197.8144     -3197.8144     -3275.9364     -3275.9364      302.34025      302.34025      47454.15       47454.15       12.210266      12.210266    
     23000  -3195.297      -3195.297      -3276.9221     -3276.9221      315.89787      315.89787      47636.831      47636.831     -366.58456     -366.58456    
Loop time of 17.2192 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.018 ns/day, 4.783 hours/ns, 58.075 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.025     | 17.025     | 17.025     |   0.0 | 98.87
Neigh   | 0.11437    | 0.11437    | 0.11437    |   0.0 |  0.66
Comm    | 0.013696   | 0.013696   | 0.013696   |   0.0 |  0.08
Output  | 3.5337e-05 | 3.5337e-05 | 3.5337e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.36
Other   |            | 0.004918   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3296 ave        3296 max        3296 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:       118914 ave      118914 max      118914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118914
Ave neighs/atom = 59.457
Neighbor list builds = 23
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 = 312.964611116421, Press = 1.49033725159045
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3195.297      -3195.297      -3276.9221     -3276.9221      315.89787      315.89787      47636.831      47636.831     -366.58456     -366.58456    
     24000  -3197.6488     -3197.6488     -3278.6394     -3278.6394      313.4419       313.4419       47613.618      47613.618     -285.49143     -285.49143    
Loop time of 17.2492 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.009 ns/day, 4.791 hours/ns, 57.974 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.05      | 17.05      | 17.05      |   0.0 | 98.84
Neigh   | 0.11931    | 0.11931    | 0.11931    |   0.0 |  0.69
Comm    | 0.013755   | 0.013755   | 0.013755   |   0.0 |  0.08
Output  | 2.3794e-05 | 2.3794e-05 | 2.3794e-05 |   0.0 |  0.00
Modify  | 0.06163    | 0.06163    | 0.06163    |   0.0 |  0.36
Other   |            | 0.004881   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 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:       118690 ave      118690 max      118690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118690
Ave neighs/atom = 59.345
Neighbor list builds = 24
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 = 312.84980105141, Press = 1.03652772538247
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3197.6488     -3197.6488     -3278.6394     -3278.6394      313.4419       313.4419       47613.618      47613.618     -285.49143     -285.49143    
     25000  -3193.2955     -3193.2955     -3276.6323     -3276.6323      322.52193      322.52193      47691.451      47691.451     -469.7682      -469.7682     
Loop time of 17.2001 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.023 ns/day, 4.778 hours/ns, 58.139 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.001     | 17.001     | 17.001     |   0.0 | 98.84
Neigh   | 0.11862    | 0.11862    | 0.11862    |   0.0 |  0.69
Comm    | 0.01376    | 0.01376    | 0.01376    |   0.0 |  0.08
Output  | 2.5729e-05 | 2.5729e-05 | 2.5729e-05 |   0.0 |  0.00
Modify  | 0.061609   | 0.061609   | 0.061609   |   0.0 |  0.36
Other   |            | 0.004873   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3347 ave        3347 max        3347 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:       118700 ave      118700 max      118700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118700
Ave neighs/atom = 59.35
Neighbor list builds = 24
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 = 312.853848456457, Press = 0.237472681380342
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3193.2955     -3193.2955     -3276.6323     -3276.6323      322.52193      322.52193      47691.451      47691.451     -469.7682      -469.7682     
     26000  -3198.469      -3198.469      -3278.9861     -3278.9861      311.60928      311.60928      47456.088      47456.088     -23.212433     -23.212433    
Loop time of 17.2461 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.010 ns/day, 4.791 hours/ns, 57.984 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.047     | 17.047     | 17.047     |   0.0 | 98.84
Neigh   | 0.11888    | 0.11888    | 0.11888    |   0.0 |  0.69
Comm    | 0.013745   | 0.013745   | 0.013745   |   0.0 |  0.08
Output  | 2.3905e-05 | 2.3905e-05 | 2.3905e-05 |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.36
Other   |            | 0.004874   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3318 ave        3318 max        3318 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:       118962 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481
Neighbor list builds = 24
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 = 312.786186935917, Press = -1.34380924149158
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3198.469      -3198.469      -3278.9861     -3278.9861      311.60928      311.60928      47456.088      47456.088     -23.212433     -23.212433    
     27000  -3191.8435     -3191.8435     -3274.6685     -3274.6685      320.54141      320.54141      47313.452      47313.452      500.32794      500.32794    
Loop time of 17.2153 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.019 ns/day, 4.782 hours/ns, 58.088 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.016     | 17.016     | 17.016     |   0.0 | 98.84
Neigh   | 0.11864    | 0.11864    | 0.11864    |   0.0 |  0.69
Comm    | 0.013727   | 0.013727   | 0.013727   |   0.0 |  0.08
Output  | 4.0075e-05 | 4.0075e-05 | 4.0075e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.36
Other   |            | 0.004872   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3291 ave        3291 max        3291 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:       119190 ave      119190 max      119190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119190
Ave neighs/atom = 59.595
Neighbor list builds = 24
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 = 312.832374557881, Press = 0.968117309939008
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3191.8435     -3191.8435     -3274.6685     -3274.6685      320.54141      320.54141      47313.452      47313.452      500.32794      500.32794    
     28000  -3194.9634     -3194.9634     -3277.1826     -3277.1826      318.19662      318.19662      47369.712      47369.712      32.380294      32.380294    
Loop time of 17.2032 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.022 ns/day, 4.779 hours/ns, 58.129 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.005     | 17.005     | 17.005     |   0.0 | 98.85
Neigh   | 0.11844    | 0.11844    | 0.11844    |   0.0 |  0.69
Comm    | 0.01371    | 0.01371    | 0.01371    |   0.0 |  0.08
Output  | 2.4125e-05 | 2.4125e-05 | 2.4125e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.36
Other   |            | 0.004872   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3358 ave        3358 max        3358 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:       119462 ave      119462 max      119462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119462
Ave neighs/atom = 59.731
Neighbor list builds = 24
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 = 312.850662824529, Press = 1.70989436067816
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3194.9634     -3194.9634     -3277.1826     -3277.1826      318.19662      318.19662      47369.712      47369.712      32.380294      32.380294    
     29000  -3196.832      -3196.832      -3276.4631     -3276.4631      308.18057      308.18057      47330.354      47330.354      184.73761      184.73761    
Loop time of 17.2749 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.001 ns/day, 4.799 hours/ns, 57.888 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.081     | 17.081     | 17.081     |   0.0 | 98.88
Neigh   | 0.11396    | 0.11396    | 0.11396    |   0.0 |  0.66
Comm    | 0.013674   | 0.013674   | 0.013674   |   0.0 |  0.08
Output  | 2.4095e-05 | 2.4095e-05 | 2.4095e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.36
Other   |            | 0.00488    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3363 ave        3363 max        3363 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:       119034 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517
Neighbor list builds = 23
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 = 312.869627176953, Press = 1.2488527728473
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3196.832      -3196.832      -3276.4631     -3276.4631      308.18057      308.18057      47330.354      47330.354      184.73761      184.73761    
     30000  -3193.8629     -3193.8629     -3275.5104     -3275.5104      315.98442      315.98442      47520.132      47520.132     -48.819692     -48.819692    
Loop time of 17.2331 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.014 ns/day, 4.787 hours/ns, 58.028 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.039     | 17.039     | 17.039     |   0.0 | 98.87
Neigh   | 0.11384    | 0.11384    | 0.11384    |   0.0 |  0.66
Comm    | 0.013713   | 0.013713   | 0.013713   |   0.0 |  0.08
Output  | 3.742e-05  | 3.742e-05  | 3.742e-05  |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.36
Other   |            | 0.004908   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 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:       119112 ave      119112 max      119112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119112
Ave neighs/atom = 59.556
Neighbor list builds = 23
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 = 312.924649996238, Press = 1.65589012502552
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3193.8629     -3193.8629     -3275.5104     -3275.5104      315.98442      315.98442      47520.132      47520.132     -48.819692     -48.819692    
     31000  -3195.6717     -3195.6717     -3275.2831     -3275.2831      308.10433      308.10433      47584.989      47584.989     -304.46252     -304.46252    
Loop time of 17.1709 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.032 ns/day, 4.770 hours/ns, 58.238 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    | 16.977     | 16.977     | 16.977     |   0.0 | 98.87
Neigh   | 0.11385    | 0.11385    | 0.11385    |   0.0 |  0.66
Comm    | 0.013742   | 0.013742   | 0.013742   |   0.0 |  0.08
Output  | 2.7471e-05 | 2.7471e-05 | 2.7471e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.36
Other   |            | 0.004892   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3316 ave        3316 max        3316 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:       119050 ave      119050 max      119050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119050
Ave neighs/atom = 59.525
Neighbor list builds = 23
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 = 313.0492249534, Press = 2.36328683735543
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3195.6717     -3195.6717     -3275.2831     -3275.2831      308.10433      308.10433      47584.989      47584.989     -304.46252     -304.46252    
     32000  -3197.43       -3197.43       -3277.6862     -3277.6862      310.59995      310.59995      47674.719      47674.719     -540.50326     -540.50326    
Loop time of 17.2479 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.009 ns/day, 4.791 hours/ns, 57.978 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.049     | 17.049     | 17.049     |   0.0 | 98.85
Neigh   | 0.11879    | 0.11879    | 0.11879    |   0.0 |  0.69
Comm    | 0.013772   | 0.013772   | 0.013772   |   0.0 |  0.08
Output  | 2.6419e-05 | 2.6419e-05 | 2.6419e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.36
Other   |            | 0.004873   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3323 ave        3323 max        3323 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:       118808 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404
Neighbor list builds = 24
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 = 312.931031808477, Press = 1.51335294418544
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3197.43       -3197.43       -3277.6862     -3277.6862      310.59995      310.59995      47674.719      47674.719     -540.50326     -540.50326    
     33000  -3199.8976     -3199.8976     -3277.6701     -3277.6701      300.98763      300.98763      47586.651      47586.651     -427.69497     -427.69497    
Loop time of 17.2112 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.020 ns/day, 4.781 hours/ns, 58.102 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.017     | 17.017     | 17.017     |   0.0 | 98.87
Neigh   | 0.11423    | 0.11423    | 0.11423    |   0.0 |  0.66
Comm    | 0.013633   | 0.013633   | 0.013633   |   0.0 |  0.08
Output  | 2.2793e-05 | 2.2793e-05 | 2.2793e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.36
Other   |            | 0.004874   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3308 ave        3308 max        3308 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:       118878 ave      118878 max      118878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118878
Ave neighs/atom = 59.439
Neighbor list builds = 23
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 = 312.934142377101, Press = 0.460518157768645
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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3199.8976     -3199.8976     -3277.6701     -3277.6701      300.98763      300.98763      47586.651      47586.651     -427.69497     -427.69497    
     34000  -3195.8506     -3195.8506     -3276.6731     -3276.6731      312.79132      312.79132      47380.387      47380.387      230.98225      230.98225    
Loop time of 17.254 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.008 ns/day, 4.793 hours/ns, 57.957 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.055     | 17.055     | 17.055     |   0.0 | 98.84
Neigh   | 0.11893    | 0.11893    | 0.11893    |   0.0 |  0.69
Comm    | 0.013754   | 0.013754   | 0.013754   |   0.0 |  0.08
Output  | 3.8913e-05 | 3.8913e-05 | 3.8913e-05 |   0.0 |  0.00
Modify  | 0.061677   | 0.061677   | 0.061677   |   0.0 |  0.36
Other   |            | 0.00489    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3342 ave        3342 max        3342 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:       119216 ave      119216 max      119216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119216
Ave neighs/atom = 59.608
Neighbor list builds = 24
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 = 312.893728582565, Press = -0.2640690541466
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3195.8506     -3195.8506     -3276.6731     -3276.6731      312.79132      312.79132      47380.387      47380.387      230.98225      230.98225    
     35000  -3194.5697     -3194.5697     -3277.0312     -3277.0312      319.13455      319.13455      47339.961      47339.961      321.61642      321.61642    
Loop time of 17.2599 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.006 ns/day, 4.794 hours/ns, 57.938 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.061     | 17.061     | 17.061     |   0.0 | 98.85
Neigh   | 0.119      | 0.119      | 0.119      |   0.0 |  0.69
Comm    | 0.013685   | 0.013685   | 0.013685   |   0.0 |  0.08
Output  | 2.3654e-05 | 2.3654e-05 | 2.3654e-05 |   0.0 |  0.00
Modify  | 0.061582   | 0.061582   | 0.061582   |   0.0 |  0.36
Other   |            | 0.004887   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3357 ave        3357 max        3357 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:       119310 ave      119310 max      119310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119310
Ave neighs/atom = 59.655
Neighbor list builds = 24
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 = 312.928170614772, Press = 0.834382498026821
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3194.5697     -3194.5697     -3277.0312     -3277.0312      319.13455      319.13455      47339.961      47339.961      321.61642      321.61642    
     36000  -3197.5369     -3197.5369     -3278.2176     -3278.2176      312.24277      312.24277      47345.615      47345.615      196.7193       196.7193     
Loop time of 17.2402 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.012 ns/day, 4.789 hours/ns, 58.004 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.047     | 17.047     | 17.047     |   0.0 | 98.88
Neigh   | 0.11331    | 0.11331    | 0.11331    |   0.0 |  0.66
Comm    | 0.013669   | 0.013669   | 0.013669   |   0.0 |  0.08
Output  | 2.3624e-05 | 2.3624e-05 | 2.3624e-05 |   0.0 |  0.00
Modify  | 0.061638   | 0.061638   | 0.061638   |   0.0 |  0.36
Other   |            | 0.0049     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3337 ave        3337 max        3337 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:       119634 ave      119634 max      119634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119634
Ave neighs/atom = 59.817
Neighbor list builds = 23
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 = 312.955438043555, Press = 1.31332677379531
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3197.5369     -3197.5369     -3278.2176     -3278.2176      312.24277      312.24277      47345.615      47345.615      196.7193       196.7193     
     37000  -3198.1914     -3198.1914     -3278.84       -3278.84        312.11852      312.11852      47439.537      47439.537      30.631787      30.631787    
Loop time of 17.1922 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.026 ns/day, 4.776 hours/ns, 58.166 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.994     | 16.994     | 16.994     |   0.0 | 98.85
Neigh   | 0.11821    | 0.11821    | 0.11821    |   0.0 |  0.69
Comm    | 0.013635   | 0.013635   | 0.013635   |   0.0 |  0.08
Output  | 3.3874e-05 | 3.3874e-05 | 3.3874e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.36
Other   |            | 0.004868   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3316 ave        3316 max        3316 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:       119110 ave      119110 max      119110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119110
Ave neighs/atom = 59.555
Neighbor list builds = 24
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 = 312.850348316862, Press = 1.23615488224629
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3198.1914     -3198.1914     -3278.84       -3278.84        312.11852      312.11852      47439.537      47439.537      30.631787      30.631787    
     38000  -3198.4699     -3198.4699     -3278.0835     -3278.0835      308.1128       308.1128       47451.54       47451.54      -32.822187     -32.822187    
Loop time of 17.2034 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.022 ns/day, 4.779 hours/ns, 58.128 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    | 17.009     | 17.009     | 17.009     |   0.0 | 98.87
Neigh   | 0.11376    | 0.11376    | 0.11376    |   0.0 |  0.66
Comm    | 0.013708   | 0.013708   | 0.013708   |   0.0 |  0.08
Output  | 2.5117e-05 | 2.5117e-05 | 2.5117e-05 |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.36
Other   |            | 0.004932   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3367 ave        3367 max        3367 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:       119158 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579
Neighbor list builds = 23
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 = 312.829177623638, Press = 1.00077704877058
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3198.4699     -3198.4699     -3278.0835     -3278.0835      308.1128       308.1128       47451.54       47451.54      -32.822187     -32.822187    
     39000  -3197.6139     -3197.6139     -3277.8926     -3277.8926      310.687        310.687        47377.967      47377.967      338.09495      338.09495    
Loop time of 17.2206 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.017 ns/day, 4.784 hours/ns, 58.070 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.027     | 17.027     | 17.027     |   0.0 | 98.87
Neigh   | 0.11388    | 0.11388    | 0.11388    |   0.0 |  0.66
Comm    | 0.013706   | 0.013706   | 0.013706   |   0.0 |  0.08
Output  | 2.4175e-05 | 2.4175e-05 | 2.4175e-05 |   0.0 |  0.00
Modify  | 0.061606   | 0.061606   | 0.061606   |   0.0 |  0.36
Other   |            | 0.004907   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 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:       119144 ave      119144 max      119144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119144
Ave neighs/atom = 59.572
Neighbor list builds = 23
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 = 312.855593036775, Press = 2.04834460065363
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3197.6139     -3197.6139     -3277.8926     -3277.8926      310.687        310.687        47377.967      47377.967      338.09495      338.09495    
     40000  -3195.8314     -3195.8314     -3277.6645     -3277.6645      316.70246      316.70246      47655.634      47655.634     -346.19371     -346.19371    
Loop time of 17.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.021 ns/day, 4.780 hours/ns, 58.109 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    | 17.01      | 17.01      | 17.01      |   0.0 | 98.84
Neigh   | 0.11905    | 0.11905    | 0.11905    |   0.0 |  0.69
Comm    | 0.013738   | 0.013738   | 0.013738   |   0.0 |  0.08
Output  | 2.2452e-05 | 2.2452e-05 | 2.2452e-05 |   0.0 |  0.00
Modify  | 0.061661   | 0.061661   | 0.061661   |   0.0 |  0.36
Other   |            | 0.004889   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3350 ave        3350 max        3350 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:       118726 ave      118726 max      118726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118726
Ave neighs/atom = 59.363
Neighbor list builds = 24
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 = 312.824606395502, Press = 2.06402188651843
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3195.8314     -3195.8314     -3277.6645     -3277.6645      316.70246      316.70246      47655.634      47655.634     -346.19371     -346.19371    
     41000  -3192.2788     -3192.2788     -3274.1966     -3274.1966      317.03027      317.03027      47700.289      47700.289     -471.05322     -471.05322    
Loop time of 17.1888 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.027 ns/day, 4.775 hours/ns, 58.178 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.99      | 16.99      | 16.99      |   0.0 | 98.84
Neigh   | 0.11854    | 0.11854    | 0.11854    |   0.0 |  0.69
Comm    | 0.013743   | 0.013743   | 0.013743   |   0.0 |  0.08
Output  | 4.0596e-05 | 4.0596e-05 | 4.0596e-05 |   0.0 |  0.00
Modify  | 0.06168    | 0.06168    | 0.06168    |   0.0 |  0.36
Other   |            | 0.004887   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3324 ave        3324 max        3324 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:       118648 ave      118648 max      118648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118648
Ave neighs/atom = 59.324
Neighbor list builds = 24
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 = 312.840294594232, Press = 0.721105432403198
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3192.2788     -3192.2788     -3274.1966     -3274.1966      317.03027      317.03027      47700.289      47700.289     -471.05322     -471.05322    
     42000  -3197.4976     -3197.4976     -3277.5648     -3277.5648      309.86861      309.86861      47516.122      47516.122     -41.042174     -41.042174    
Loop time of 17.1543 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.037 ns/day, 4.765 hours/ns, 58.294 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    | 16.955     | 16.955     | 16.955     |   0.0 | 98.84
Neigh   | 0.11933    | 0.11933    | 0.11933    |   0.0 |  0.70
Comm    | 0.013753   | 0.013753   | 0.013753   |   0.0 |  0.08
Output  | 2.3394e-05 | 2.3394e-05 | 2.3394e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.36
Other   |            | 0.004885   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3349 ave        3349 max        3349 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:       119002 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501
Neighbor list builds = 24
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 = 312.909837184542, Press = 0.898754103979169
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3197.4976     -3197.4976     -3277.5648     -3277.5648      309.86861      309.86861      47516.122      47516.122     -41.042174     -41.042174    
     43000  -3197.7139     -3197.7139     -3277.2264     -3277.2264      307.72184      307.72184      47567.185      47567.185     -57.443782     -57.443782    
Loop time of 17.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.015 ns/day, 4.785 hours/ns, 58.048 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.028     | 17.028     | 17.028     |   0.0 | 98.85
Neigh   | 0.1186     | 0.1186     | 0.1186     |   0.0 |  0.69
Comm    | 0.013775   | 0.013775   | 0.013775   |   0.0 |  0.08
Output  | 2.3754e-05 | 2.3754e-05 | 2.3754e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.36
Other   |            | 0.004883   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3327 ave        3327 max        3327 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:       118794 ave      118794 max      118794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118794
Ave neighs/atom = 59.397
Neighbor list builds = 24
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 = 312.915680195155, Press = 0.329685031434937
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -3197.7139     -3197.7139     -3277.2264     -3277.2264      307.72184      307.72184      47567.185      47567.185     -57.443782     -57.443782    
     44000  -3190.3539     -3190.3539     -3273.0077     -3273.0077      319.87902      319.87902      47587.238      47587.238     -253.99554     -253.99554    
Loop time of 17.2323 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.014 ns/day, 4.787 hours/ns, 58.031 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    | 17.033     | 17.033     | 17.033     |   0.0 | 98.84
Neigh   | 0.11877    | 0.11877    | 0.11877    |   0.0 |  0.69
Comm    | 0.013799   | 0.013799   | 0.013799   |   0.0 |  0.08
Output  | 3.6508e-05 | 3.6508e-05 | 3.6508e-05 |   0.0 |  0.00
Modify  | 0.061616   | 0.061616   | 0.061616   |   0.0 |  0.36
Other   |            | 0.004911   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3327 ave        3327 max        3327 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:       118804 ave      118804 max      118804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118804
Ave neighs/atom = 59.402
Neighbor list builds = 24
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 = 312.937626521944, Press = 0.310370510481199
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -3190.3539     -3190.3539     -3273.0077     -3273.0077      319.87902      319.87902      47587.238      47587.238     -253.99554     -253.99554    
     45000  -3197.1758     -3197.1758     -3280.0919     -3280.0919      320.89405      320.89405      47542.961      47542.961     -206.24534     -206.24534    
Loop time of 17.2036 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.022 ns/day, 4.779 hours/ns, 58.127 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    | 17.009     | 17.009     | 17.009     |   0.0 | 98.87
Neigh   | 0.11453    | 0.11453    | 0.11453    |   0.0 |  0.67
Comm    | 0.013685   | 0.013685   | 0.013685   |   0.0 |  0.08
Output  | 2.3374e-05 | 2.3374e-05 | 2.3374e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.36
Other   |            | 0.004881   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3312 ave        3312 max        3312 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:       118650 ave      118650 max      118650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118650
Ave neighs/atom = 59.325
Neighbor list builds = 23
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 = 312.999300158594, Press = -0.245907843606493
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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3197.1758     -3197.1758     -3280.0919     -3280.0919      320.89405      320.89405      47542.961      47542.961     -206.24534     -206.24534    
     46000  -3197.0356     -3197.0356     -3277.9438     -3277.9438      313.12297      313.12297      47333.664      47333.664      343.13857      343.13857    
Loop time of 17.2321 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.014 ns/day, 4.787 hours/ns, 58.031 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.037     | 17.037     | 17.037     |   0.0 | 98.87
Neigh   | 0.11432    | 0.11432    | 0.11432    |   0.0 |  0.66
Comm    | 0.013718   | 0.013718   | 0.013718   |   0.0 |  0.08
Output  | 2.4496e-05 | 2.4496e-05 | 2.4496e-05 |   0.0 |  0.00
Modify  | 0.061716   | 0.061716   | 0.061716   |   0.0 |  0.36
Other   |            | 0.004905   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3314 ave        3314 max        3314 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:       119108 ave      119108 max      119108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119108
Ave neighs/atom = 59.554
Neighbor list builds = 23
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
47463.4881203383

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0