# 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.532111041247845*${_u_distance}
variable latticeconst_converted equal 3.532111041247845*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.53211104124785
Lattice spacing in x,y,z = 3.5321110 3.5321110 3.5321110
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.321110 35.321110 35.321110)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.321110 35.321110 35.321110)
  create_atoms CPU = 0.003 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_KimJungLee_2012_LiMg__MO_427397414195_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 44065.9406253475    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*1*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 44065.9406253475*1000

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

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

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   -3215.8636   -3215.8636   -3296.7787   -3296.7787       313.15       313.15    44065.941    44065.941    1961.3095    1961.3095 
    1000   -3121.5912   -3121.5912   -3204.6688   -3204.6688    321.51895    321.51895    45168.019    45168.019   -633.84064   -633.84064 
Loop time of 174.067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.352 hours/ns, 5.745 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.18     | 173.18     | 173.18     |   0.0 | 99.49
Neigh   | 0.40916    | 0.40916    | 0.40916    |   0.0 |  0.24
Comm    | 0.08865    | 0.08865    | 0.08865    |   0.0 |  0.05
Output  | 0.00020403 | 0.00020403 | 0.00020403 |   0.0 |  0.00
Modify  | 0.33472    | 0.33472    | 0.33472    |   0.0 |  0.19
Other   |            | 0.05413    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3272.00 ave        3272 max        3272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120648.0 ave      120648 max      120648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120648
Ave neighs/atom = 60.324000
Neighbor list builds = 19
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
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   -3121.5912   -3121.5912   -3204.6688   -3204.6688    321.51895    321.51895    45168.019    45168.019   -633.84064   -633.84064 
    2000   -3130.5854   -3130.5854   -3209.3869   -3209.3869    304.96992    304.96992    44741.667    44741.667    101.09308    101.09308 
Loop time of 173.475 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.187 hours/ns, 5.765 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.48     | 172.48     | 172.48     |   0.0 | 99.43
Neigh   | 0.51946    | 0.51946    | 0.51946    |   0.0 |  0.30
Comm    | 0.090613   | 0.090613   | 0.090613   |   0.0 |  0.05
Output  | 0.00019001 | 0.00019001 | 0.00019001 |   0.0 |  0.00
Modify  | 0.33254    | 0.33254    | 0.33254    |   0.0 |  0.19
Other   |            | 0.05385    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3284.00 ave        3284 max        3284 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121072.0 ave      121072 max      121072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121072
Ave neighs/atom = 60.536000
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
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   -3130.5854   -3130.5854   -3209.3869   -3209.3869    304.96992    304.96992    44741.667    44741.667    101.09308    101.09308 
    3000   -3122.4202   -3122.4202   -3204.1675   -3204.1675    316.37071    316.37071    44792.548    44792.548    266.60553    266.60553 
Loop time of 173.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.145 hours/ns, 5.770 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.35     | 172.35     | 172.35     |   0.0 | 99.44
Neigh   | 0.4976     | 0.4976     | 0.4976     |   0.0 |  0.29
Comm    | 0.090712   | 0.090712   | 0.090712   |   0.0 |  0.05
Output  | 0.00018866 | 0.00018866 | 0.00018866 |   0.0 |  0.00
Modify  | 0.3325     | 0.3325     | 0.3325     |   0.0 |  0.19
Other   |            | 0.05391    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3332.00 ave        3332 max        3332 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121324.0 ave      121324 max      121324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121324
Ave neighs/atom = 60.662000
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
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 
    3000   -3122.4202   -3122.4202   -3204.1675   -3204.1675    316.37071    316.37071    44792.548    44792.548    266.60553    266.60553 
    4000   -3127.7537   -3127.7537   -3208.8417   -3208.8417    313.81903    313.81903    44722.063    44722.063    207.77086    207.77086 
Loop time of 173.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.063 hours/ns, 5.779 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.03     | 172.03     | 172.03     |   0.0 | 99.42
Neigh   | 0.51926    | 0.51926    | 0.51926    |   0.0 |  0.30
Comm    | 0.090066   | 0.090066   | 0.090066   |   0.0 |  0.05
Output  | 0.00018838 | 0.00018838 | 0.00018838 |   0.0 |  0.00
Modify  | 0.33257    | 0.33257    | 0.33257    |   0.0 |  0.19
Other   |            | 0.05411    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3280.00 ave        3280 max        3280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121156.0 ave      121156 max      121156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121156
Ave neighs/atom = 60.578000
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
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   -3127.7537   -3127.7537   -3208.8417   -3208.8417    313.81903    313.81903    44722.063    44722.063    207.77086    207.77086 
    5000   -3124.0313   -3124.0313    -3206.568    -3206.568    319.42532    319.42532    45042.497    45042.497   -427.92541   -427.92541 
Loop time of 172.84 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.011 hours/ns, 5.786 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.89     | 171.89     | 171.89     |   0.0 | 99.45
Neigh   | 0.47555    | 0.47555    | 0.47555    |   0.0 |  0.28
Comm    | 0.089294   | 0.089294   | 0.089294   |   0.0 |  0.05
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.33348    | 0.33348    | 0.33348    |   0.0 |  0.19
Other   |            | 0.05421    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3271.00 ave        3271 max        3271 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120900.0 ave      120900 max      120900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120900
Ave neighs/atom = 60.450000
Neighbor list builds = 22
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 = 316.820799899891, Press = -232.40688562345
next a
jump SELF top
variable a loop 2000
run 1000
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 
    5000   -3124.0313   -3124.0313    -3206.568    -3206.568    319.42532    319.42532    45042.497    45042.497   -427.92541   -427.92541 
    6000   -3128.9635   -3128.9635   -3209.1166   -3209.1166    310.20074    310.20074     44854.61     44854.61    -103.6916    -103.6916 
Loop time of 172.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.042 hours/ns, 5.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.96     | 171.96     | 171.96     |   0.0 | 99.43
Neigh   | 0.49695    | 0.49695    | 0.49695    |   0.0 |  0.29
Comm    | 0.089696   | 0.089696   | 0.089696   |   0.0 |  0.05
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.34892    | 0.34892    | 0.34892    |   0.0 |  0.20
Other   |            | 0.05412    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3281.00 ave        3281 max        3281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120940.0 ave      120940 max      120940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120940
Ave neighs/atom = 60.470000
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.194408968562, Press = -51.0241949701025
next a
jump SELF top
variable a loop 2000
run 1000
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   -3128.9635   -3128.9635   -3209.1166   -3209.1166    310.20074    310.20074     44854.61     44854.61    -103.6916    -103.6916 
    7000   -3127.7259   -3127.7259   -3208.1197   -3208.1197    311.13215    311.13215    44708.658    44708.658    226.48859    226.48859 
Loop time of 173.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.062 hours/ns, 5.780 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.03     | 172.03     | 172.03     |   0.0 | 99.43
Neigh   | 0.49794    | 0.49794    | 0.49794    |   0.0 |  0.29
Comm    | 0.089956   | 0.089956   | 0.089956   |   0.0 |  0.05
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.34869    | 0.34869    | 0.34869    |   0.0 |  0.20
Other   |            | 0.05414    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3272.00 ave        3272 max        3272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121222.0 ave      121222 max      121222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121222
Ave neighs/atom = 60.611000
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.37941393406, Press = -23.7171016917494
next a
jump SELF top
variable a loop 2000
run 1000
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   -3127.7259   -3127.7259   -3208.1197   -3208.1197    311.13215    311.13215    44708.658    44708.658    226.48859    226.48859 
    8000   -3126.5545   -3126.5545   -3207.1665   -3207.1665    311.97674    311.97674    44651.319    44651.319     459.8234     459.8234 
Loop time of 173.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.108 hours/ns, 5.774 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.2      | 172.2      | 172.2      |   0.0 | 99.43
Neigh   | 0.49739    | 0.49739    | 0.49739    |   0.0 |  0.29
Comm    | 0.090173   | 0.090173   | 0.090173   |   0.0 |  0.05
Output  | 0.00015394 | 0.00015394 | 0.00015394 |   0.0 |  0.00
Modify  | 0.34931    | 0.34931    | 0.34931    |   0.0 |  0.20
Other   |            | 0.05392    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3316.00 ave        3316 max        3316 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121456.0 ave      121456 max      121456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121456
Ave neighs/atom = 60.728000
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.675313822072, Press = -4.46489604261646
next a
jump SELF top
variable a loop 2000
run 1000
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   -3126.5545   -3126.5545   -3207.1665   -3207.1665    311.97674    311.97674    44651.319    44651.319     459.8234     459.8234 
    9000   -3124.4415   -3124.4415   -3205.0372   -3205.0372     311.9138     311.9138    44882.742    44882.742    11.537284    11.537284 
Loop time of 172.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 47.993 hours/ns, 5.788 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.78     | 171.78     | 171.78     |   0.0 | 99.43
Neigh   | 0.49705    | 0.49705    | 0.49705    |   0.0 |  0.29
Comm    | 0.089803   | 0.089803   | 0.089803   |   0.0 |  0.05
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.34996    | 0.34996    | 0.34996    |   0.0 |  0.20
Other   |            | 0.05369    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3322.00 ave        3322 max        3322 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121326.0 ave      121326 max      121326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121326
Ave neighs/atom = 60.663000
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.4189094152, Press = -8.02648135454585
next a
jump SELF top
variable a loop 2000
run 1000
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   -3124.4415   -3124.4415   -3205.0372   -3205.0372     311.9138     311.9138    44882.742    44882.742    11.537284    11.537284 
   10000   -3126.9833   -3126.9833   -3207.7183   -3207.7183    312.45311    312.45311    44796.391    44796.391    74.779274    74.779274 
Loop time of 172.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.041 hours/ns, 5.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.96     | 171.96     | 171.96     |   0.0 | 99.43
Neigh   | 0.49655    | 0.49655    | 0.49655    |   0.0 |  0.29
Comm    | 0.089911   | 0.089911   | 0.089911   |   0.0 |  0.05
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.34886    | 0.34886    | 0.34886    |   0.0 |  0.20
Other   |            | 0.05403    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3329.00 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121300.0 ave      121300 max      121300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121300
Ave neighs/atom = 60.650000
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.609796614928, Press = -5.05954619092278
next a
jump SELF top
variable a loop 2000
run 1000
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 
   10000   -3126.9833   -3126.9833   -3207.7183   -3207.7183    312.45311    312.45311    44796.391    44796.391    74.779274    74.779274 
   11000   -3124.5389   -3124.5389   -3206.8913   -3206.8913    318.71249    318.71249    44888.818    44888.818   -70.332983   -70.332983 
Loop time of 173.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.116 hours/ns, 5.773 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.23     | 172.23     | 172.23     |   0.0 | 99.43
Neigh   | 0.49725    | 0.49725    | 0.49725    |   0.0 |  0.29
Comm    | 0.090259   | 0.090259   | 0.090259   |   0.0 |  0.05
Output  | 0.00019607 | 0.00019607 | 0.00019607 |   0.0 |  0.00
Modify  | 0.34953    | 0.34953    | 0.34953    |   0.0 |  0.20
Other   |            | 0.0539     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3316.00 ave        3316 max        3316 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121292.0 ave      121292 max      121292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121292
Ave neighs/atom = 60.646000
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.766335314626, Press = -6.786853614915
next a
jump SELF top
variable a loop 2000
run 1000
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 
   11000   -3124.5389   -3124.5389   -3206.8913   -3206.8913    318.71249    318.71249    44888.818    44888.818   -70.332983   -70.332983 
   12000   -3127.3679   -3127.3679   -3207.2342   -3207.2342    309.09059    309.09059    44869.292    44869.292   -110.33226   -110.33226 
Loop time of 173.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.188 hours/ns, 5.764 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.46     | 172.46     | 172.46     |   0.0 | 99.42
Neigh   | 0.51921    | 0.51921    | 0.51921    |   0.0 |  0.30
Comm    | 0.090443   | 0.090443   | 0.090443   |   0.0 |  0.05
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.34909    | 0.34909    | 0.34909    |   0.0 |  0.20
Other   |            | 0.05413    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3314.00 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121182.0 ave      121182 max      121182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121182
Ave neighs/atom = 60.591000
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 = 313.486517274548, Press = -1.65482073174939
next a
jump SELF top
variable a loop 2000
run 1000
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 
   12000   -3127.3679   -3127.3679   -3207.2342   -3207.2342    309.09059    309.09059    44869.292    44869.292   -110.33226   -110.33226 
   13000   -3125.2527   -3125.2527   -3205.6777   -3205.6777    311.25285    311.25285    44946.559    44946.559    -235.1225    -235.1225 
Loop time of 173.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.126 hours/ns, 5.772 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.24     | 172.24     | 172.24     |   0.0 | 99.42
Neigh   | 0.51934    | 0.51934    | 0.51934    |   0.0 |  0.30
Comm    | 0.090106   | 0.090106   | 0.090106   |   0.0 |  0.05
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.34945    | 0.34945    | 0.34945    |   0.0 |  0.20
Other   |            | 0.05371    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3276.00 ave        3276 max        3276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120964.0 ave      120964 max      120964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120964
Ave neighs/atom = 60.482000
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 = 313.408399962545, Press = -7.00342392245552
next a
jump SELF top
variable a loop 2000
run 1000
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   -3125.2527   -3125.2527   -3205.6777   -3205.6777    311.25285    311.25285    44946.559    44946.559    -235.1225    -235.1225 
   14000   -3121.6501   -3121.6501   -3204.8693   -3204.8693    322.06692    322.06692    44860.673    44860.673    138.99966    138.99966 
Loop time of 173.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.121 hours/ns, 5.772 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.22     | 172.22     | 172.22     |   0.0 | 99.42
Neigh   | 0.51826    | 0.51826    | 0.51826    |   0.0 |  0.30
Comm    | 0.090515   | 0.090515   | 0.090515   |   0.0 |  0.05
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.3498     | 0.3498     | 0.3498     |   0.0 |  0.20
Other   |            | 0.05424    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3348.00 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121068.0 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534000
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 = 313.310292743249, Press = -5.80264300452008
next a
jump SELF top
variable a loop 2000
run 1000
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 
   14000   -3121.6501   -3121.6501   -3204.8693   -3204.8693    322.06692    322.06692    44860.673    44860.673    138.99966    138.99966 
   15000   -3129.0614   -3129.0614   -3208.0306   -3208.0306     305.6188     305.6188    44682.522    44682.522    365.65333    365.65333 
Loop time of 197.812 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.948 hours/ns, 5.055 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.67     | 196.67     | 196.67     |   0.0 | 99.42
Neigh   | 0.56492    | 0.56492    | 0.56492    |   0.0 |  0.29
Comm    | 0.10158    | 0.10158    | 0.10158    |   0.0 |  0.05
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.42033    | 0.42033    | 0.42033    |   0.0 |  0.21
Other   |            | 0.05848    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121324.0 ave      121324 max      121324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121324
Ave neighs/atom = 60.662000
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 = 313.361533928522, Press = -3.25391411371245
next a
jump SELF top
variable a loop 2000
run 1000
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   -3129.0614   -3129.0614   -3208.0306   -3208.0306     305.6188     305.6188    44682.522    44682.522    365.65333    365.65333 
   16000   -3121.9743   -3121.9743     -3205.51     -3205.51    323.29179    323.29179    44814.686    44814.686    217.69958    217.69958 
Loop time of 202.588 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.274 hours/ns, 4.936 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.42     | 201.42     | 201.42     |   0.0 | 99.43
Neigh   | 0.56547    | 0.56547    | 0.56547    |   0.0 |  0.28
Comm    | 0.1035     | 0.1035     | 0.1035     |   0.0 |  0.05
Output  | 0.00015341 | 0.00015341 | 0.00015341 |   0.0 |  0.00
Modify  | 0.43616    | 0.43616    | 0.43616    |   0.0 |  0.22
Other   |            | 0.05897    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3272.00 ave        3272 max        3272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121284.0 ave      121284 max      121284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121284
Ave neighs/atom = 60.642000
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 = 313.484784517287, Press = -2.15006445456354
next a
jump SELF top
variable a loop 2000
run 1000
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   -3121.9743   -3121.9743     -3205.51     -3205.51    323.29179    323.29179    44814.686    44814.686    217.69958    217.69958 
   17000   -3126.7446   -3126.7446   -3205.4619   -3205.4619    304.64411    304.64411    44996.294    44996.294   -363.02381   -363.02381 
Loop time of 173.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.169 hours/ns, 5.767 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.39     | 172.39     | 172.39     |   0.0 | 99.41
Neigh   | 0.5199     | 0.5199     | 0.5199     |   0.0 |  0.30
Comm    | 0.090555   | 0.090555   | 0.090555   |   0.0 |  0.05
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.35044    | 0.35044    | 0.35044    |   0.0 |  0.20
Other   |            | 0.05384    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120884.0 ave      120884 max      120884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120884
Ave neighs/atom = 60.442000
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 = 313.397574255237, Press = -3.27372427741718
next a
jump SELF top
variable a loop 2000
run 1000
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 
   17000   -3126.7446   -3126.7446   -3205.4619   -3205.4619    304.64411    304.64411    44996.294    44996.294   -363.02381   -363.02381 
   18000   -3125.3825   -3125.3825   -3207.2995   -3207.2995    317.02753    317.02753    44957.831    44957.831   -316.56247   -316.56247 
Loop time of 173.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.079 hours/ns, 5.777 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.09     | 172.09     | 172.09     |   0.0 | 99.43
Neigh   | 0.4978     | 0.4978     | 0.4978     |   0.0 |  0.29
Comm    | 0.089994   | 0.089994   | 0.089994   |   0.0 |  0.05
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.34892    | 0.34892    | 0.34892    |   0.0 |  0.20
Other   |            | 0.05441    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121018.0 ave      121018 max      121018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121018
Ave neighs/atom = 60.509000
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.31441162469, Press = -4.63305345732156
next a
jump SELF top
variable a loop 2000
run 1000
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   -3125.3825   -3125.3825   -3207.2995   -3207.2995    317.02753    317.02753    44957.831    44957.831   -316.56247   -316.56247 
   19000   -3126.6986   -3126.6986   -3207.2025   -3207.2025    311.55841    311.55841    44634.026    44634.026    523.81474    523.81474 
Loop time of 172.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.027 hours/ns, 5.784 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.91     | 171.91     | 171.91     |   0.0 | 99.43
Neigh   | 0.49722    | 0.49722    | 0.49722    |   0.0 |  0.29
Comm    | 0.089796   | 0.089796   | 0.089796   |   0.0 |  0.05
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.34952    | 0.34952    | 0.34952    |   0.0 |  0.20
Other   |            | 0.05383    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3302.00 ave        3302 max        3302 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121048.0 ave      121048 max      121048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121048
Ave neighs/atom = 60.524000
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.453122875101, Press = -4.86371361009389
next a
jump SELF top
variable a loop 2000
run 1000
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   -3126.6986   -3126.6986   -3207.2025   -3207.2025    311.55841    311.55841    44634.026    44634.026    523.81474    523.81474 
   20000   -3128.3391   -3128.3391    -3209.902    -3209.902    315.65686    315.65686    44662.096    44662.096    336.76017    336.76017 
Loop time of 174.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.385 hours/ns, 5.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.15     | 173.15     | 173.15     |   0.0 | 99.40
Neigh   | 0.54337    | 0.54337    | 0.54337    |   0.0 |  0.31
Comm    | 0.092147   | 0.092147   | 0.092147   |   0.0 |  0.05
Output  | 0.00015307 | 0.00015307 | 0.00015307 |   0.0 |  0.00
Modify  | 0.35071    | 0.35071    | 0.35071    |   0.0 |  0.20
Other   |            | 0.05315    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121338.0 ave      121338 max      121338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121338
Ave neighs/atom = 60.669000
Neighbor list builds = 25
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.304031272025, Press = -1.73621208216408
next a
jump SELF top
variable a loop 2000
run 1000
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 
   20000   -3128.3391   -3128.3391    -3209.902    -3209.902    315.65686    315.65686    44662.096    44662.096    336.76017    336.76017 
   21000   -3123.8811   -3123.8811   -3206.8918   -3206.8918    321.26008    321.26008    44872.313    44872.313   -37.921149   -37.921149 
Loop time of 174.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.414 hours/ns, 5.738 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.27     | 173.27     | 173.27     |   0.0 | 99.42
Neigh   | 0.52217    | 0.52217    | 0.52217    |   0.0 |  0.30
Comm    | 0.092099   | 0.092099   | 0.092099   |   0.0 |  0.05
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.35174    | 0.35174    | 0.35174    |   0.0 |  0.20
Other   |            | 0.05275    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3268.00 ave        3268 max        3268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120928.0 ave      120928 max      120928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120928
Ave neighs/atom = 60.464000
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 = 313.324396278201, Press = -1.46823546225624
next a
jump SELF top
variable a loop 2000
run 1000
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 
   21000   -3123.8811   -3123.8811   -3206.8918   -3206.8918    321.26008    321.26008    44872.313    44872.313   -37.921149   -37.921149 
   22000   -3128.6685   -3128.6685   -3207.4069   -3207.4069    304.72548    304.72548    44766.843    44766.843    138.10359    138.10359 
Loop time of 173.995 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.332 hours/ns, 5.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173        | 173        | 173        |   0.0 | 99.43
Neigh   | 0.5007     | 0.5007     | 0.5007     |   0.0 |  0.29
Comm    | 0.092035   | 0.092035   | 0.092035   |   0.0 |  0.05
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.35071    | 0.35071    | 0.35071    |   0.0 |  0.20
Other   |            | 0.0532     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121116.0 ave      121116 max      121116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121116
Ave neighs/atom = 60.558000
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.251587610494, Press = -2.15217746183622
next a
jump SELF top
variable a loop 2000
run 1000
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   -3128.6685   -3128.6685   -3207.4069   -3207.4069    304.72548    304.72548    44766.843    44766.843    138.10359    138.10359 
   23000   -3125.8219   -3125.8219   -3210.0032   -3210.0032    325.79012    325.79012     44803.23     44803.23    37.077974    37.077974 
Loop time of 174.182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.384 hours/ns, 5.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.19     | 173.19     | 173.19     |   0.0 | 99.43
Neigh   | 0.50034    | 0.50034    | 0.50034    |   0.0 |  0.29
Comm    | 0.092139   | 0.092139   | 0.092139   |   0.0 |  0.05
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.35145    | 0.35145    | 0.35145    |   0.0 |  0.20
Other   |            | 0.05279    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3319.00 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121052.0 ave      121052 max      121052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121052
Ave neighs/atom = 60.526000
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.201357927076, Press = -1.14657313245216
next a
jump SELF top
variable a loop 2000
run 1000
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 
   23000   -3125.8219   -3125.8219   -3210.0032   -3210.0032    325.79012    325.79012     44803.23     44803.23    37.077974    37.077974 
   24000   -3127.6295   -3127.6295   -3209.3198   -3209.3198    316.14993    316.14993    44701.686    44701.686    338.90535    338.90535 
Loop time of 173.991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.331 hours/ns, 5.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173        | 173        | 173        |   0.0 | 99.43
Neigh   | 0.4998     | 0.4998     | 0.4998     |   0.0 |  0.29
Comm    | 0.091211   | 0.091211   | 0.091211   |   0.0 |  0.05
Output  | 0.00020393 | 0.00020393 | 0.00020393 |   0.0 |  0.00
Modify  | 0.35186    | 0.35186    | 0.35186    |   0.0 |  0.20
Other   |            | 0.05265    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3263.00 ave        3263 max        3263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120970.0 ave      120970 max      120970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120970
Ave neighs/atom = 60.485000
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.184321610263, Press = -0.858513945191517
next a
jump SELF top
variable a loop 2000
run 1000
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 
   24000   -3127.6295   -3127.6295   -3209.3198   -3209.3198    316.14993    316.14993    44701.686    44701.686    338.90535    338.90535 
   25000   -3125.3176   -3125.3176   -3206.8574   -3206.8574    315.56765    315.56765    45081.823    45081.823   -541.16256   -541.16256 
Loop time of 173.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.292 hours/ns, 5.752 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.86     | 172.86     | 172.86     |   0.0 | 99.43
Neigh   | 0.49966    | 0.49966    | 0.49966    |   0.0 |  0.29
Comm    | 0.092092   | 0.092092   | 0.092092   |   0.0 |  0.05
Output  | 0.00019204 | 0.00019204 | 0.00019204 |   0.0 |  0.00
Modify  | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.20
Other   |            | 0.05285    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3342.00 ave        3342 max        3342 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121044.0 ave      121044 max      121044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121044
Ave neighs/atom = 60.522000
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.143120329074, Press = -0.697969031442706
next a
jump SELF top
variable a loop 2000
run 1000
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   -3125.3176   -3125.3176   -3206.8574   -3206.8574    315.56765    315.56765    45081.823    45081.823   -541.16256   -541.16256 
   26000   -3126.4856   -3126.4856   -3205.1057   -3205.1057    304.26776    304.26776    44995.411    44995.411   -418.74753   -418.74753 
Loop time of 202.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.165 hours/ns, 4.946 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.02     | 201.02     | 201.02     |   0.0 | 99.42
Neigh   | 0.56918    | 0.56918    | 0.56918    |   0.0 |  0.28
Comm    | 0.10399    | 0.10399    | 0.10399    |   0.0 |  0.05
Output  | 0.00019653 | 0.00019653 | 0.00019653 |   0.0 |  0.00
Modify  | 0.43977    | 0.43977    | 0.43977    |   0.0 |  0.22
Other   |            | 0.05951    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3309.00 ave        3309 max        3309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120912.0 ave      120912 max      120912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120912
Ave neighs/atom = 60.456000
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 = 313.160065813346, Press = -3.53696861866628
next a
jump SELF top
variable a loop 2000
run 1000
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   -3126.4856   -3126.4856   -3205.1057   -3205.1057    304.26776    304.26776    44995.411    44995.411   -418.74753   -418.74753 
   27000    -3121.814    -3121.814    -3204.843    -3204.843    321.33066    321.33066    44965.813    44965.813   -192.08404   -192.08404 
Loop time of 202.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.216 hours/ns, 4.941 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.21     | 201.21     | 201.21     |   0.0 | 99.42
Neigh   | 0.56795    | 0.56795    | 0.56795    |   0.0 |  0.28
Comm    | 0.10358    | 0.10358    | 0.10358    |   0.0 |  0.05
Output  | 0.00021105 | 0.00021105 | 0.00021105 |   0.0 |  0.00
Modify  | 0.43889    | 0.43889    | 0.43889    |   0.0 |  0.22
Other   |            | 0.05981    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3303.00 ave        3303 max        3303 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121016.0 ave      121016 max      121016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121016
Ave neighs/atom = 60.508000
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 = 313.291730468627, Press = -2.59169898293433
next a
jump SELF top
variable a loop 2000
run 1000
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 
   27000    -3121.814    -3121.814    -3204.843    -3204.843    321.33066    321.33066    44965.813    44965.813   -192.08404   -192.08404 
   28000    -3126.689    -3126.689   -3207.6061   -3207.6061    313.15744    313.15744    44845.528    44845.528     38.16654     38.16654 
Loop time of 185.91 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.465 ns/day, 51.642 hours/ns, 5.379 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.83     | 184.83     | 184.83     |   0.0 | 99.42
Neigh   | 0.54078    | 0.54078    | 0.54078    |   0.0 |  0.29
Comm    | 0.096421   | 0.096421   | 0.096421   |   0.0 |  0.05
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.38745    | 0.38745    | 0.38745    |   0.0 |  0.21
Other   |            | 0.05654    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3354.00 ave        3354 max        3354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120912.0 ave      120912 max      120912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120912
Ave neighs/atom = 60.456000
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 = 313.362964490023, Press = -1.09822263599782
next a
jump SELF top
variable a loop 2000
run 1000
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    -3126.689    -3126.689   -3207.6061   -3207.6061    313.15744    313.15744    44845.528    44845.528     38.16654     38.16654 
   29000   -3125.5824   -3125.5824   -3206.5805   -3206.5805    313.47111    313.47111    44989.079    44989.079    -356.4759    -356.4759 
Loop time of 193.487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.746 hours/ns, 5.168 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.37     | 192.37     | 192.37     |   0.0 | 99.43
Neigh   | 0.53766    | 0.53766    | 0.53766    |   0.0 |  0.28
Comm    | 0.10035    | 0.10035    | 0.10035    |   0.0 |  0.05
Output  | 0.00021354 | 0.00021354 | 0.00021354 |   0.0 |  0.00
Modify  | 0.41663    | 0.41663    | 0.41663    |   0.0 |  0.22
Other   |            | 0.05756    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3269.00 ave        3269 max        3269 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120996.0 ave      120996 max      120996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120996
Ave neighs/atom = 60.498000
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.32943911982, Press = -2.18767029913689
next a
jump SELF top
variable a loop 2000
run 1000
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 
   29000   -3125.5824   -3125.5824   -3206.5805   -3206.5805    313.47111    313.47111    44989.079    44989.079    -356.4759    -356.4759 
   30000   -3123.8873   -3123.8873    -3205.508    -3205.508    315.88028    315.88028    44818.633    44818.633    58.335697    58.335697 
Loop time of 202.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.184 hours/ns, 4.944 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.11     | 201.11     | 201.11     |   0.0 | 99.43
Neigh   | 0.54345    | 0.54345    | 0.54345    |   0.0 |  0.27
Comm    | 0.10414    | 0.10414    | 0.10414    |   0.0 |  0.05
Output  | 0.00019368 | 0.00019368 | 0.00019368 |   0.0 |  0.00
Modify  | 0.44324    | 0.44324    | 0.44324    |   0.0 |  0.22
Other   |            | 0.05984    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121020.0 ave      121020 max      121020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121020
Ave neighs/atom = 60.510000
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.44283101317, Press = -3.7073779702755
next a
jump SELF top
variable a loop 2000
run 1000
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   -3123.8873   -3123.8873    -3205.508    -3205.508    315.88028    315.88028    44818.633    44818.633    58.335697    58.335697 
   31000   -3122.7778   -3122.7778   -3203.4739   -3203.4739    312.30232    312.30232    44716.159    44716.159    474.14663    474.14663 
Loop time of 184.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.468 ns/day, 51.236 hours/ns, 5.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 183.4      | 183.4      | 183.4      |   0.0 | 99.43
Neigh   | 0.51646    | 0.51646    | 0.51646    |   0.0 |  0.28
Comm    | 0.095573   | 0.095573   | 0.095573   |   0.0 |  0.05
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.38426    | 0.38426    | 0.38426    |   0.0 |  0.21
Other   |            | 0.05534    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3309.00 ave        3309 max        3309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121124.0 ave      121124 max      121124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121124
Ave neighs/atom = 60.562000
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.416491450074, Press = -1.57158927252285
next a
jump SELF top
variable a loop 2000
run 1000
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 
   31000   -3122.7778   -3122.7778   -3203.4739   -3203.4739    312.30232    312.30232    44716.159    44716.159    474.14663    474.14663 
   32000   -3129.2074   -3129.2074   -3210.9695   -3210.9695    316.42765    316.42765    44589.019    44589.019    467.44998    467.44998 
Loop time of 174.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.435 hours/ns, 5.735 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.37     | 173.37     | 173.37     |   0.0 | 99.43
Neigh   | 0.49996    | 0.49996    | 0.49996    |   0.0 |  0.29
Comm    | 0.091973   | 0.091973   | 0.091973   |   0.0 |  0.05
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.35165    | 0.35165    | 0.35165    |   0.0 |  0.20
Other   |            | 0.05273    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3350.00 ave        3350 max        3350 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121494.0 ave      121494 max      121494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121494
Ave neighs/atom = 60.747000
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.471808569021, Press = 0.965351419039447
next a
jump SELF top
variable a loop 2000
run 1000
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 
   32000   -3129.2074   -3129.2074   -3210.9695   -3210.9695    316.42765    316.42765    44589.019    44589.019    467.44998    467.44998 
   33000   -3125.3326   -3125.3326   -3205.5306   -3205.5306    310.37452    310.37452    44972.328    44972.328   -250.55801   -250.55801 
Loop time of 173.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.326 hours/ns, 5.748 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.96     | 172.96     | 172.96     |   0.0 | 99.42
Neigh   | 0.52082    | 0.52082    | 0.52082    |   0.0 |  0.30
Comm    | 0.092714   | 0.092714   | 0.092714   |   0.0 |  0.05
Output  | 0.00015378 | 0.00015378 | 0.00015378 |   0.0 |  0.00
Modify  | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.20
Other   |            | 0.05237    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3351.00 ave        3351 max        3351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120986.0 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120986
Ave neighs/atom = 60.493000
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 = 313.389360747078, Press = -0.185994581564486
next a
jump SELF top
variable a loop 2000
run 1000
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 
   33000   -3125.3326   -3125.3326   -3205.5306   -3205.5306    310.37452    310.37452    44972.328    44972.328   -250.55801   -250.55801 
   34000   -3128.7261   -3128.7261    -3207.708    -3207.708    305.66791    305.66791    44862.802    44862.802   -109.23274   -109.23274 
Loop time of 173.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.281 hours/ns, 5.753 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.8      | 172.8      | 172.8      |   0.0 | 99.42
Neigh   | 0.52068    | 0.52068    | 0.52068    |   0.0 |  0.30
Comm    | 0.092267   | 0.092267   | 0.092267   |   0.0 |  0.05
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.35105    | 0.35105    | 0.35105    |   0.0 |  0.20
Other   |            | 0.05234    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3336.00 ave        3336 max        3336 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120904.0 ave      120904 max      120904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120904
Ave neighs/atom = 60.452000
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 = 313.440259025572, Press = -1.80669209323276
next a
jump SELF top
variable a loop 2000
run 1000
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   -3128.7261   -3128.7261    -3207.708    -3207.708    305.66791    305.66791    44862.802    44862.802   -109.23274   -109.23274 
   35000   -3124.7682   -3124.7682   -3206.7824   -3206.7824    317.40321    317.40321    44811.932    44811.932    115.22306    115.22306 
Loop time of 174.067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.352 hours/ns, 5.745 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.05     | 173.05     | 173.05     |   0.0 | 99.42
Neigh   | 0.52192    | 0.52192    | 0.52192    |   0.0 |  0.30
Comm    | 0.092384   | 0.092384   | 0.092384   |   0.0 |  0.05
Output  | 0.00015606 | 0.00015606 | 0.00015606 |   0.0 |  0.00
Modify  | 0.35122    | 0.35122    | 0.35122    |   0.0 |  0.20
Other   |            | 0.05236    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3249.00 ave        3249 max        3249 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121156.0 ave      121156 max      121156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121156
Ave neighs/atom = 60.578000
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 = 313.416570662479, Press = -2.45932996648407
next a
jump SELF top
variable a loop 2000
run 1000
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 
   35000   -3124.7682   -3124.7682   -3206.7824   -3206.7824    317.40321    317.40321    44811.932    44811.932    115.22306    115.22306 
   36000   -3125.9678   -3125.9678   -3207.4809   -3207.4809    315.46438    315.46438    44721.012    44721.012    298.48585    298.48585 
Loop time of 174.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.582 hours/ns, 5.718 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.9      | 173.9      | 173.9      |   0.0 | 99.43
Neigh   | 0.49927    | 0.49927    | 0.49927    |   0.0 |  0.29
Comm    | 0.092533   | 0.092533   | 0.092533   |   0.0 |  0.05
Output  | 0.0001548  | 0.0001548  | 0.0001548  |   0.0 |  0.00
Modify  | 0.35398    | 0.35398    | 0.35398    |   0.0 |  0.20
Other   |            | 0.05265    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121154.0 ave      121154 max      121154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121154
Ave neighs/atom = 60.577000
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.348301136271, Press = -0.70398751576974
next a
jump SELF top
variable a loop 2000
run 1000
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   -3125.9678   -3125.9678   -3207.4809   -3207.4809    315.46438    315.46438    44721.012    44721.012    298.48585    298.48585 
   37000   -3120.4322   -3120.4322   -3204.8762   -3204.8762    326.80709    326.80709    44937.007    44937.007   -35.769881   -35.769881 
Loop time of 175.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.746 hours/ns, 5.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.46     | 174.46     | 174.46     |   0.0 | 99.42
Neigh   | 0.52428    | 0.52428    | 0.52428    |   0.0 |  0.30
Comm    | 0.092433   | 0.092433   | 0.092433   |   0.0 |  0.05
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.35582    | 0.35582    | 0.35582    |   0.0 |  0.20
Other   |            | 0.05302    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3312.00 ave        3312 max        3312 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121092.0 ave      121092 max      121092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121092
Ave neighs/atom = 60.546000
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 = 313.425032322731, Press = 0.128104259598827
next a
jump SELF top
variable a loop 2000
run 1000
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 
   37000   -3120.4322   -3120.4322   -3204.8762   -3204.8762    326.80709    326.80709    44937.007    44937.007   -35.769881   -35.769881 
   38000    -3126.524    -3126.524   -3206.6382   -3206.6382    310.04992    310.04992    44927.946    44927.946   -242.81682   -242.81682 
Loop time of 173.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.301 hours/ns, 5.751 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.87     | 172.87     | 172.87     |   0.0 | 99.41
Neigh   | 0.52176    | 0.52176    | 0.52176    |   0.0 |  0.30
Comm    | 0.092573   | 0.092573   | 0.092573   |   0.0 |  0.05
Output  | 0.00015517 | 0.00015517 | 0.00015517 |   0.0 |  0.00
Modify  | 0.35162    | 0.35162    | 0.35162    |   0.0 |  0.20
Other   |            | 0.05258    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3311.00 ave        3311 max        3311 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121082.0 ave      121082 max      121082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121082
Ave neighs/atom = 60.541000
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 = 313.479190725349, Press = -0.471592938660654
next a
jump SELF top
variable a loop 2000
run 1000
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 
   38000    -3126.524    -3126.524   -3206.6382   -3206.6382    310.04992    310.04992    44927.946    44927.946   -242.81682   -242.81682 
   39000   -3124.1512   -3124.1512   -3206.0414   -3206.0414    316.92325    316.92325    45056.635    45056.635   -470.92541   -470.92541 
Loop time of 174.035 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.343 hours/ns, 5.746 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.02     | 173.02     | 173.02     |   0.0 | 99.41
Neigh   | 0.52328    | 0.52328    | 0.52328    |   0.0 |  0.30
Comm    | 0.092506   | 0.092506   | 0.092506   |   0.0 |  0.05
Output  | 0.00018897 | 0.00018897 | 0.00018897 |   0.0 |  0.00
Modify  | 0.35083    | 0.35083    | 0.35083    |   0.0 |  0.20
Other   |            | 0.05199    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3293.00 ave        3293 max        3293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120984.0 ave      120984 max      120984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120984
Ave neighs/atom = 60.492000
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 = 313.460884396886, Press = -1.21914815155562
next a
jump SELF top
variable a loop 2000
run 1000
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 
   39000   -3124.1512   -3124.1512   -3206.0414   -3206.0414    316.92325    316.92325    45056.635    45056.635   -470.92541   -470.92541 
   40000   -3131.3321   -3131.3321    -3210.469    -3210.469    306.26798    306.26798    44776.432    44776.432     10.76037     10.76037 
Loop time of 174.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.348 hours/ns, 5.745 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.06     | 173.06     | 173.06     |   0.0 | 99.43
Neigh   | 0.49923    | 0.49923    | 0.49923    |   0.0 |  0.29
Comm    | 0.092055   | 0.092055   | 0.092055   |   0.0 |  0.05
Output  | 0.00019168 | 0.00019168 | 0.00019168 |   0.0 |  0.00
Modify  | 0.35134    | 0.35134    | 0.35134    |   0.0 |  0.20
Other   |            | 0.05243    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3276.00 ave        3276 max        3276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121048.0 ave      121048 max      121048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121048
Ave neighs/atom = 60.524000
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.431257579851, Press = -1.67025477452087
next a
jump SELF top
variable a loop 2000
run 1000
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 
   40000   -3131.3321   -3131.3321    -3210.469    -3210.469    306.26798    306.26798    44776.432    44776.432     10.76037     10.76037 
   41000   -3123.9791   -3123.9791   -3205.4516   -3205.4516    315.30698    315.30698     44747.67     44747.67    282.02618    282.02618 
Loop time of 173.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.329 hours/ns, 5.748 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.97     | 172.97     | 172.97     |   0.0 | 99.42
Neigh   | 0.51995    | 0.51995    | 0.51995    |   0.0 |  0.30
Comm    | 0.091263   | 0.091263   | 0.091263   |   0.0 |  0.05
Output  | 0.00015289 | 0.00015289 | 0.00015289 |   0.0 |  0.00
Modify  | 0.35099    | 0.35099    | 0.35099    |   0.0 |  0.20
Other   |            | 0.05268    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3367.00 ave        3367 max        3367 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121250.0 ave      121250 max      121250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121250
Ave neighs/atom = 60.625000
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 = 313.395696180864, Press = -1.06752073792295
next a
jump SELF top
variable a loop 2000
run 1000
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   -3123.9791   -3123.9791   -3205.4516   -3205.4516    315.30698    315.30698     44747.67     44747.67    282.02618    282.02618 
   42000   -3123.6145   -3123.6145   -3204.9425   -3204.9425    314.74777    314.74777    44846.788    44846.788    122.22236    122.22236 
Loop time of 173.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.159 hours/ns, 5.768 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.36     | 172.36     | 172.36     |   0.0 | 99.41
Neigh   | 0.52006    | 0.52006    | 0.52006    |   0.0 |  0.30
Comm    | 0.091822   | 0.091822   | 0.091822   |   0.0 |  0.05
Output  | 0.00015251 | 0.00015251 | 0.00015251 |   0.0 |  0.00
Modify  | 0.35041    | 0.35041    | 0.35041    |   0.0 |  0.20
Other   |            | 0.05382    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3277.00 ave        3277 max        3277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121012.0 ave      121012 max      121012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121012
Ave neighs/atom = 60.506000
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 = 313.350703446252, Press = -1.17601932360769
next a
jump SELF top
variable a loop 2000
run 1000
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 
   42000   -3123.6145   -3123.6145   -3204.9425   -3204.9425    314.74777    314.74777    44846.788    44846.788    122.22236    122.22236 
   43000   -3130.4776   -3130.4776   -3208.8559   -3208.8559    303.33221    303.33221    44722.551    44722.551    192.70668    192.70668 
Loop time of 173.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.133 hours/ns, 5.771 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.29     | 172.29     | 172.29     |   0.0 | 99.43
Neigh   | 0.49764    | 0.49764    | 0.49764    |   0.0 |  0.29
Comm    | 0.090434   | 0.090434   | 0.090434   |   0.0 |  0.05
Output  | 0.00015673 | 0.00015673 | 0.00015673 |   0.0 |  0.00
Modify  | 0.35028    | 0.35028    | 0.35028    |   0.0 |  0.20
Other   |            | 0.05313    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3268.00 ave        3268 max        3268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121068.0 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534000
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.288150622934, Press = -1.00198911683869
next a
jump SELF top
variable a loop 2000
run 1000
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 
   43000   -3130.4776   -3130.4776   -3208.8559   -3208.8559    303.33221    303.33221    44722.551    44722.551    192.70668    192.70668 
   44000   -3124.5717   -3124.5717   -3207.7876   -3207.7876    322.05427    322.05427    44850.168    44850.168   -50.563253   -50.563253 
Loop time of 173.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.171 hours/ns, 5.766 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.42     | 172.42     | 172.42     |   0.0 | 99.43
Neigh   | 0.49901    | 0.49901    | 0.49901    |   0.0 |  0.29
Comm    | 0.09021    | 0.09021    | 0.09021    |   0.0 |  0.05
Output  | 0.00019451 | 0.00019451 | 0.00019451 |   0.0 |  0.00
Modify  | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.20
Other   |            | 0.05309    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3348.00 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121046.0 ave      121046 max      121046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121046
Ave neighs/atom = 60.523000
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.275493589643, Press = -0.557174851100628
next a
jump SELF top
variable a loop 2000
run 1000
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   -3124.5717   -3124.5717   -3207.7876   -3207.7876    322.05427    322.05427    44850.168    44850.168   -50.563253   -50.563253 
   45000   -3124.3916   -3124.3916   -3207.0064   -3207.0064    319.72802    319.72802    44979.851    44979.851   -287.20204   -287.20204 
Loop time of 173.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.093 hours/ns, 5.776 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.12     | 172.12     | 172.12     |   0.0 | 99.41
Neigh   | 0.51912    | 0.51912    | 0.51912    |   0.0 |  0.30
Comm    | 0.091597   | 0.091597   | 0.091597   |   0.0 |  0.05
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.35107    | 0.35107    | 0.35107    |   0.0 |  0.20
Other   |            | 0.0534     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3312.00 ave        3312 max        3312 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120988.0 ave      120988 max      120988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120988
Ave neighs/atom = 60.494000
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 = 313.226636160606, Press = -0.522796009591086
next a
jump SELF top
variable a loop 2000
run 1000
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 
   45000   -3124.3916   -3124.3916   -3207.0064   -3207.0064    319.72802    319.72802    44979.851    44979.851   -287.20204   -287.20204 
   46000   -3126.9113   -3126.9113   -3206.2735   -3206.2735     307.1402     307.1402    45123.329    45123.329   -702.20133   -702.20133 
Loop time of 173.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.117 hours/ns, 5.773 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.21     | 172.21     | 172.21     |   0.0 | 99.42
Neigh   | 0.51834    | 0.51834    | 0.51834    |   0.0 |  0.30
Comm    | 0.090888   | 0.090888   | 0.090888   |   0.0 |  0.05
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.35082    | 0.35082    | 0.35082    |   0.0 |  0.20
Other   |            | 0.05301    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3345.00 ave        3345 max        3345 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120986.0 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120986
Ave neighs/atom = 60.493000
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 = 313.191043490509, Press = -0.316099169653585
next a
jump SELF top
variable a loop 2000
run 1000
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 
   46000   -3126.9113   -3126.9113   -3206.2735   -3206.2735     307.1402     307.1402    45123.329    45123.329   -702.20133   -702.20133 
   47000   -3121.2928   -3121.2928   -3205.5387   -3205.5387    326.04017    326.04017    44999.425    44999.425   -226.64665   -226.64665 
Loop time of 172.923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.034 hours/ns, 5.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.91     | 171.91     | 171.91     |   0.0 | 99.41
Neigh   | 0.51874    | 0.51874    | 0.51874    |   0.0 |  0.30
Comm    | 0.090779   | 0.090779   | 0.090779   |   0.0 |  0.05
Output  | 0.0001531  | 0.0001531  | 0.0001531  |   0.0 |  0.00
Modify  | 0.35035    | 0.35035    | 0.35035    |   0.0 |  0.20
Other   |            | 0.05298    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3269.00 ave        3269 max        3269 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120968.0 ave      120968 max      120968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120968
Ave neighs/atom = 60.484000
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 = 313.2177622036, Press = -1.01254015819385
next a
jump SELF top
variable a loop 2000
run 1000
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 
   47000   -3121.2928   -3121.2928   -3205.5387   -3205.5387    326.04017    326.04017    44999.425    44999.425   -226.64665   -226.64665 
   48000   -3126.5482   -3126.5482   -3209.4433   -3209.4433    320.81261    320.81261     44895.16     44895.16   -162.44521   -162.44521 
Loop time of 172.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.007 hours/ns, 5.786 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.83     | 171.83     | 171.83     |   0.0 | 99.43
Neigh   | 0.49731    | 0.49731    | 0.49731    |   0.0 |  0.29
Comm    | 0.089902   | 0.089902   | 0.089902   |   0.0 |  0.05
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.35023    | 0.35023    | 0.35023    |   0.0 |  0.20
Other   |            | 0.05327    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3299.00 ave        3299 max        3299 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120804.0 ave      120804 max      120804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120804
Ave neighs/atom = 60.402000
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.24641111717, Press = -0.912499914941641
next a
jump SELF top
variable a loop 2000
run 1000
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 
   48000   -3126.5482   -3126.5482   -3209.4433   -3209.4433    320.81261    320.81261     44895.16     44895.16   -162.44521   -162.44521 
   49000   -3121.0078   -3121.0078   -3205.2562   -3205.2562    326.05001    326.05001    45070.933    45070.933   -411.80342   -411.80342 
Loop time of 172.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.030 hours/ns, 5.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.89     | 171.89     | 171.89     |   0.0 | 99.42
Neigh   | 0.51743    | 0.51743    | 0.51743    |   0.0 |  0.30
Comm    | 0.090566   | 0.090566   | 0.090566   |   0.0 |  0.05
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.34979    | 0.34979    | 0.34979    |   0.0 |  0.20
Other   |            | 0.05348    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3317.00 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120902.0 ave      120902 max      120902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120902
Ave neighs/atom = 60.451000
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 = 313.286221611456, Press = -1.45760812048153
next a
jump SELF top
variable a loop 2000
run 1000
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 
   49000   -3121.0078   -3121.0078   -3205.2562   -3205.2562    326.05001    326.05001    45070.933    45070.933   -411.80342   -411.80342 
   50000   -3125.7957   -3125.7957   -3206.8039   -3206.8039    313.51008    313.51008    44814.104    44814.104    41.630686    41.630686 
Loop time of 172.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.045 hours/ns, 5.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.97     | 171.97     | 171.97     |   0.0 | 99.43
Neigh   | 0.49609    | 0.49609    | 0.49609    |   0.0 |  0.29
Comm    | 0.090436   | 0.090436   | 0.090436   |   0.0 |  0.05
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.35005    | 0.35005    | 0.35005    |   0.0 |  0.20
Other   |            | 0.05325    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3285.00 ave        3285 max        3285 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121064.0 ave      121064 max      121064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121064
Ave neighs/atom = 60.532000
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.3144378801, Press = -1.77153208202731
next a
jump SELF top
variable a loop 2000
run 1000
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 
   50000   -3125.7957   -3125.7957   -3206.8039   -3206.8039    313.51008    313.51008    44814.104    44814.104    41.630686    41.630686 
   51000    -3122.156    -3122.156   -3207.4283   -3207.4283    330.01239    330.01239    44640.486    44640.486    641.54926    641.54926 
Loop time of 173.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.127 hours/ns, 5.772 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.24     | 172.24     | 172.24     |   0.0 | 99.41
Neigh   | 0.51981    | 0.51981    | 0.51981    |   0.0 |  0.30
Comm    | 0.091265   | 0.091265   | 0.091265   |   0.0 |  0.05
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.35021    | 0.35021    | 0.35021    |   0.0 |  0.20
Other   |            | 0.05311    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121246.0 ave      121246 max      121246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121246
Ave neighs/atom = 60.623000
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 = 313.297103550204, Press = -0.589130357157039
next a
jump SELF top
variable a loop 2000
run 1000
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 
   51000    -3122.156    -3122.156   -3207.4283   -3207.4283    330.01239    330.01239    44640.486    44640.486    641.54926    641.54926 
   52000   -3128.4367   -3128.4367   -3211.1184   -3211.1184    319.98674    319.98674    44717.654    44717.654    172.63599    172.63599 
Loop time of 173.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.089 hours/ns, 5.776 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.08     | 172.08     | 172.08     |   0.0 | 99.40
Neigh   | 0.53839    | 0.53839    | 0.53839    |   0.0 |  0.31
Comm    | 0.091521   | 0.091521   | 0.091521   |   0.0 |  0.05
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.35099    | 0.35099    | 0.35099    |   0.0 |  0.20
Other   |            | 0.05355    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3307.00 ave        3307 max        3307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121122.0 ave      121122 max      121122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121122
Ave neighs/atom = 60.561000
Neighbor list builds = 25
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.343369053819, Press = 0.403768214460091
next a
jump SELF top
variable a loop 2000
run 1000
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 
   52000   -3128.4367   -3128.4367   -3211.1184   -3211.1184    319.98674    319.98674    44717.654    44717.654    172.63599    172.63599 
   53000   -3125.0169   -3125.0169    -3204.854    -3204.854    308.97769    308.97769    45072.688    45072.688   -478.66873   -478.66873 
Loop time of 172.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.042 hours/ns, 5.782 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.94     | 171.94     | 171.94     |   0.0 | 99.41
Neigh   | 0.51916    | 0.51916    | 0.51916    |   0.0 |  0.30
Comm    | 0.091501   | 0.091501   | 0.091501   |   0.0 |  0.05
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.35018    | 0.35018    | 0.35018    |   0.0 |  0.20
Other   |            | 0.05322    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3287.00 ave        3287 max        3287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120780.0 ave      120780 max      120780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120780
Ave neighs/atom = 60.390000
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 = 313.286850379482, Press = -0.317061150284684
next a
jump SELF top
variable a loop 2000
run 1000
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 
   53000   -3125.0169   -3125.0169    -3204.854    -3204.854    308.97769    308.97769    45072.688    45072.688   -478.66873   -478.66873 
   54000   -3129.0701   -3129.0701   -3207.9109   -3207.9109    305.12216    305.12216    44888.058    44888.058   -199.36569   -199.36569 
Loop time of 172.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.001 hours/ns, 5.787 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.81     | 171.81     | 171.81     |   0.0 | 99.43
Neigh   | 0.49686    | 0.49686    | 0.49686    |   0.0 |  0.29
Comm    | 0.090361   | 0.090361   | 0.090361   |   0.0 |  0.05
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.35091    | 0.35091    | 0.35091    |   0.0 |  0.20
Other   |            | 0.05314    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3290.00 ave        3290 max        3290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120974.0 ave      120974 max      120974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120974
Ave neighs/atom = 60.487000
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.237370383939, Press = -0.763325307381303
next a
jump SELF top
variable a loop 2000
run 1000
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 
   54000   -3129.0701   -3129.0701   -3207.9109   -3207.9109    305.12216    305.12216    44888.058    44888.058   -199.36569   -199.36569 
   55000   -3128.4205   -3128.4205   -3210.3583   -3210.3583    317.10764    317.10764    44721.188    44721.188    230.34456    230.34456 
Loop time of 172.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.032 hours/ns, 5.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.9      | 171.9      | 171.9      |   0.0 | 99.41
Neigh   | 0.51811    | 0.51811    | 0.51811    |   0.0 |  0.30
Comm    | 0.090345   | 0.090345   | 0.090345   |   0.0 |  0.05
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.35176    | 0.35176    | 0.35176    |   0.0 |  0.20
Other   |            | 0.05351    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121114.0 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557000
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 = 313.246956387008, Press = -1.49176956748269
next a
jump SELF top
variable a loop 2000
run 1000
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 
   55000   -3128.4205   -3128.4205   -3210.3583   -3210.3583    317.10764    317.10764    44721.188    44721.188    230.34456    230.34456 
   56000   -3126.3471   -3126.3471   -3206.8509   -3206.8509    311.55809    311.55809    44747.235    44747.235    270.52627    270.52627 
Loop time of 173.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.155 hours/ns, 5.768 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.37     | 172.37     | 172.37     |   0.0 | 99.43
Neigh   | 0.49687    | 0.49687    | 0.49687    |   0.0 |  0.29
Comm    | 0.090775   | 0.090775   | 0.090775   |   0.0 |  0.05
Output  | 0.0013842  | 0.0013842  | 0.0013842  |   0.0 |  0.00
Modify  | 0.35006    | 0.35006    | 0.35006    |   0.0 |  0.20
Other   |            | 0.05353    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121100.0 ave      121100 max      121100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121100
Ave neighs/atom = 60.550000
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.195828946978, Press = -0.714352294398977
next a
jump SELF top
variable a loop 2000
run 1000
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 
   56000   -3126.3471   -3126.3471   -3206.8509   -3206.8509    311.55809    311.55809    44747.235    44747.235    270.52627    270.52627 
   57000    -3120.118    -3120.118    -3204.392    -3204.392    326.14928    326.14928    44878.363    44878.363    140.86624    140.86624 
Loop time of 173.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.102 hours/ns, 5.775 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.15     | 172.15     | 172.15     |   0.0 | 99.41
Neigh   | 0.51761    | 0.51761    | 0.51761    |   0.0 |  0.30
Comm    | 0.09187    | 0.09187    | 0.09187    |   0.0 |  0.05
Output  | 0.00015349 | 0.00015349 | 0.00015349 |   0.0 |  0.00
Modify  | 0.3508     | 0.3508     | 0.3508     |   0.0 |  0.20
Other   |            | 0.05334    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3369.00 ave        3369 max        3369 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121112.0 ave      121112 max      121112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121112
Ave neighs/atom = 60.556000
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"
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
44845.4370583352

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0