# 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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   -3221.0314   -3221.0314   -3296.7787   -3296.7787       293.15       293.15    44065.941    44065.941    1836.0463    1836.0463 
    1000   -3133.1378   -3133.1378   -3211.7086   -3211.7086    304.07709    304.07709    44925.784    44925.784   -453.25147   -453.25147 
Loop time of 174.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.413 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.42     | 173.42     | 173.42     |   0.0 | 99.50
Neigh   | 0.38851    | 0.38851    | 0.38851    |   0.0 |  0.22
Comm    | 0.08798    | 0.08798    | 0.08798    |   0.0 |  0.05
Output  | 0.00019952 | 0.00019952 | 0.00019952 |   0.0 |  0.00
Modify  | 0.3338     | 0.3338     | 0.3338     |   0.0 |  0.19
Other   |            | 0.05607    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3275.00 ave        3275 max        3275 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:      120718.0 ave      120718 max      120718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120718
Ave neighs/atom = 60.359000
Neighbor list builds = 18
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   -3133.1378   -3133.1378   -3211.7086   -3211.7086    304.07709    304.07709    44925.784    44925.784   -453.25147   -453.25147 
    2000   -3141.0779   -3141.0779    -3216.627    -3216.627    292.38275    292.38275    44479.186    44479.186    364.22951    364.22951 
Loop time of 173.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.199 hours/ns, 5.763 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.54     | 172.54     | 172.54     |   0.0 | 99.44
Neigh   | 0.49749    | 0.49749    | 0.49749    |   0.0 |  0.29
Comm    | 0.089988   | 0.089988   | 0.089988   |   0.0 |  0.05
Output  | 0.0001904  | 0.0001904  | 0.0001904  |   0.0 |  0.00
Modify  | 0.3331     | 0.3331     | 0.3331     |   0.0 |  0.19
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:        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:      121056.0 ave      121056 max      121056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121056
Ave neighs/atom = 60.528000
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.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   -3141.0779   -3141.0779    -3216.627    -3216.627    292.38275    292.38275    44479.186    44479.186    364.22951    364.22951 
    3000   -3133.8302   -3133.8302   -3211.6718   -3211.6718    301.25508    301.25508    44649.961    44649.961    229.41364    229.41364 
Loop time of 173.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.228 hours/ns, 5.760 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.67     | 172.67     | 172.67     |   0.0 | 99.45
Neigh   | 0.4755     | 0.4755     | 0.4755     |   0.0 |  0.27
Comm    | 0.089453   | 0.089453   | 0.089453   |   0.0 |  0.05
Output  | 0.00022541 | 0.00022541 | 0.00022541 |   0.0 |  0.00
Modify  | 0.33181    | 0.33181    | 0.33181    |   0.0 |  0.19
Other   |            | 0.0557     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 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:      121098.0 ave      121098 max      121098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121098
Ave neighs/atom = 60.549000
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 = 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   -3133.8302   -3133.8302   -3211.6718   -3211.6718    301.25508    301.25508    44649.961    44649.961    229.41364    229.41364 
    4000   -3139.5052   -3139.5052   -3214.1393   -3214.1393    288.84162    288.84162    44713.701    44713.701   -130.34897   -130.34897 
Loop time of 173.734 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.259 hours/ns, 5.756 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.76     | 172.76     | 172.76     |   0.0 | 99.44
Neigh   | 0.49749    | 0.49749    | 0.49749    |   0.0 |  0.29
Comm    | 0.090574   | 0.090574   | 0.090574   |   0.0 |  0.05
Output  | 0.00019016 | 0.00019016 | 0.00019016 |   0.0 |  0.00
Modify  | 0.33352    | 0.33352    | 0.33352    |   0.0 |  0.19
Other   |            | 0.05554    |            |       |  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:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
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.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   -3139.5052   -3139.5052   -3214.1393   -3214.1393    288.84162    288.84162    44713.701    44713.701   -130.34897   -130.34897 
    5000   -3135.3979   -3135.3979   -3213.5799   -3213.5799    302.57233    302.57233    44798.032    44798.032   -252.10062   -252.10062 
Loop time of 174.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.343 hours/ns, 5.746 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.44
Neigh   | 0.49931    | 0.49931    | 0.49931    |   0.0 |  0.29
Comm    | 0.08972    | 0.08972    | 0.08972    |   0.0 |  0.05
Output  | 0.00015514 | 0.00015514 | 0.00015514 |   0.0 |  0.00
Modify  | 0.33486    | 0.33486    | 0.33486    |   0.0 |  0.19
Other   |            | 0.0553     |            |       |  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:      120752.0 ave      120752 max      120752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120752
Ave neighs/atom = 60.376000
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 = 297.335807789744, Press = -262.677807049604
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   -3135.3979   -3135.3979   -3213.5799   -3213.5799    302.57233    302.57233    44798.032    44798.032   -252.10062   -252.10062 
    6000   -3139.3909   -3139.3909   -3212.3522   -3212.3522    282.36773    282.36773    44551.729    44551.729    377.08223    377.08223 
Loop time of 174.049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.347 hours/ns, 5.746 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.08     | 173.08     | 173.08     |   0.0 | 99.44
Neigh   | 0.47717    | 0.47717    | 0.47717    |   0.0 |  0.27
Comm    | 0.089664   | 0.089664   | 0.089664   |   0.0 |  0.05
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.35052    | 0.35052    | 0.35052    |   0.0 |  0.20
Other   |            | 0.05599    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 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 = 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 = 292.915718561014, Press = -29.5263496391629
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   -3139.3909   -3139.3909   -3212.3522   -3212.3522    282.36773    282.36773    44551.729    44551.729    377.08223    377.08223 
    7000   -3134.5638   -3134.5638   -3210.4337   -3210.4337    293.62436    293.62436    44703.309    44703.309    125.98768    125.98768 
Loop time of 174.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.345 hours/ns, 5.746 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.07     | 173.07     | 173.07     |   0.0 | 99.44
Neigh   | 0.4757     | 0.4757     | 0.4757     |   0.0 |  0.27
Comm    | 0.089646   | 0.089646   | 0.089646   |   0.0 |  0.05
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.35062    | 0.35062    | 0.35062    |   0.0 |  0.20
Other   |            | 0.05553    |            |       |  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:      120934.0 ave      120934 max      120934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120934
Ave neighs/atom = 60.467000
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 = 294.188643531786, Press = -1.9478664585522
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   -3134.5638   -3134.5638   -3210.4337   -3210.4337    293.62436    293.62436    44703.309    44703.309    125.98768    125.98768 
    8000   -3139.4995   -3139.4995   -3213.7843   -3213.7843    287.49017    287.49017    44658.916    44658.916    -41.48493    -41.48493 
Loop time of 173.855 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.293 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.88     | 172.88     | 172.88     |   0.0 | 99.44
Neigh   | 0.47639    | 0.47639    | 0.47639    |   0.0 |  0.27
Comm    | 0.089919   | 0.089919   | 0.089919   |   0.0 |  0.05
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.35119    | 0.35119    | 0.35119    |   0.0 |  0.20
Other   |            | 0.05519    |            |       |  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:      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 = 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 = 293.889360896429, Press = -3.30652514252805
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   -3139.4995   -3139.4995   -3213.7843   -3213.7843    287.49017    287.49017    44658.916    44658.916    -41.48493    -41.48493 
    9000   -3137.3347   -3137.3347   -3212.8554   -3212.8554    292.27282    292.27282    44739.737    44739.737   -119.42812   -119.42812 
Loop time of 173.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.309 hours/ns, 5.750 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.92     | 172.92     | 172.92     |   0.0 | 99.43
Neigh   | 0.49701    | 0.49701    | 0.49701    |   0.0 |  0.29
Comm    | 0.090342   | 0.090342   | 0.090342   |   0.0 |  0.05
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.35088    | 0.35088    | 0.35088    |   0.0 |  0.20
Other   |            | 0.0554     |            |       |  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:      121118.0 ave      121118 max      121118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121118
Ave neighs/atom = 60.559000
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 = 293.976123402149, Press = -5.9007168964516
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   -3137.3347   -3137.3347   -3212.8554   -3212.8554    292.27282    292.27282    44739.737    44739.737   -119.42812   -119.42812 
   10000   -3139.2837   -3139.2837   -3214.1092   -3214.1092    289.58241    289.58241    44666.163    44666.163   -30.173813   -30.173813 
Loop time of 173.699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.250 hours/ns, 5.757 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.7      | 172.7      | 172.7      |   0.0 | 99.43
Neigh   | 0.50167    | 0.50167    | 0.50167    |   0.0 |  0.29
Comm    | 0.090615   | 0.090615   | 0.090615   |   0.0 |  0.05
Output  | 0.00015057 | 0.00015057 | 0.00015057 |   0.0 |  0.00
Modify  | 0.35006    | 0.35006    | 0.35006    |   0.0 |  0.20
Other   |            | 0.05529    |            |       |  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:      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 = 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 = 294.476183335217, Press = -6.43241930977484
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   -3139.2837   -3139.2837   -3214.1092   -3214.1092    289.58241    289.58241    44666.163    44666.163   -30.173813   -30.173813 
   11000    -3135.474    -3135.474   -3211.3316   -3211.3316     293.5768     293.5768    44593.791    44593.791    318.62306    318.62306 
Loop time of 173.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.086 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.14     | 172.14     | 172.14     |   0.0 | 99.44
Neigh   | 0.47558    | 0.47558    | 0.47558    |   0.0 |  0.27
Comm    | 0.090139   | 0.090139   | 0.090139   |   0.0 |  0.05
Output  | 0.00015391 | 0.00015391 | 0.00015391 |   0.0 |  0.00
Modify  | 0.34914    | 0.34914    | 0.34914    |   0.0 |  0.20
Other   |            | 0.05531    |            |       |  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:      121402.0 ave      121402 max      121402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121402
Ave neighs/atom = 60.701000
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 = 294.207069076793, Press = -10.9725851517561
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 
   11000    -3135.474    -3135.474   -3211.3316   -3211.3316     293.5768     293.5768    44593.791    44593.791    318.62306    318.62306 
   12000   -3138.2095   -3138.2095   -3212.7361   -3212.7361     288.4257     288.4257    44432.069    44432.069     678.1886     678.1886 
Loop time of 173.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.183 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.49     | 172.49     | 172.49     |   0.0 | 99.44
Neigh   | 0.47398    | 0.47398    | 0.47398    |   0.0 |  0.27
Comm    | 0.08991    | 0.08991    | 0.08991    |   0.0 |  0.05
Output  | 0.00015292 | 0.00015292 | 0.00015292 |   0.0 |  0.00
Modify  | 0.3497     | 0.3497     | 0.3497     |   0.0 |  0.20
Other   |            | 0.05569    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3320.00 ave        3320 max        3320 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 = 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 = 293.797557652693, Press = 2.05469230574024
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   -3138.2095   -3138.2095   -3212.7361   -3212.7361     288.4257     288.4257    44432.069    44432.069     678.1886     678.1886 
   13000   -3139.3165   -3139.3165   -3214.4868   -3214.4868    290.91711    290.91711    44852.106    44852.106   -536.27474   -536.27474 
Loop time of 173.657 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.238 hours/ns, 5.758 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.66     | 172.66     | 172.66     |   0.0 | 99.43
Neigh   | 0.49824    | 0.49824    | 0.49824    |   0.0 |  0.29
Comm    | 0.090472   | 0.090472   | 0.090472   |   0.0 |  0.05
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.34909    | 0.34909    | 0.34909    |   0.0 |  0.20
Other   |            | 0.05627    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 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 = 293.923257328393, Press = 1.10238689878121
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   -3139.3165   -3139.3165   -3214.4868   -3214.4868    290.91711    290.91711    44852.106    44852.106   -536.27474   -536.27474 
   14000   -3136.6333   -3136.6333   -3212.2291   -3212.2291     292.5639     292.5639    44828.167    44828.167   -359.26549   -359.26549 
Loop time of 199.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.529 hours/ns, 5.002 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    | 198.77     | 198.77     | 198.77     |   0.0 | 99.43
Neigh   | 0.53709    | 0.53709    | 0.53709    |   0.0 |  0.27
Comm    | 0.10157    | 0.10157    | 0.10157    |   0.0 |  0.05
Output  | 0.0001922  | 0.0001922  | 0.0001922  |   0.0 |  0.00
Modify  | 0.43215    | 0.43215    | 0.43215    |   0.0 |  0.22
Other   |            | 0.06022    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3330.00 ave        3330 max        3330 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:      120840.0 ave      120840 max      120840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120840
Ave neighs/atom = 60.420000
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 = 293.555689066213, Press = -2.5852273109799
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 
   14000   -3136.6333   -3136.6333   -3212.2291   -3212.2291     292.5639     292.5639    44828.167    44828.167   -359.26549   -359.26549 
   15000    -3140.314    -3140.314   -3214.3406   -3214.3406    286.49063    286.49063    44645.192    44645.192    6.3516372    6.3516372 
Loop time of 173.508 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.197 hours/ns, 5.763 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.54     | 172.54     | 172.54     |   0.0 | 99.44
Neigh   | 0.47605    | 0.47605    | 0.47605    |   0.0 |  0.27
Comm    | 0.089579   | 0.089579   | 0.089579   |   0.0 |  0.05
Output  | 0.00015228 | 0.00015228 | 0.00015228 |   0.0 |  0.00
Modify  | 0.34971    | 0.34971    | 0.34971    |   0.0 |  0.20
Other   |            | 0.05545    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3250.00 ave        3250 max        3250 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:      120938.0 ave      120938 max      120938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120938
Ave neighs/atom = 60.469000
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 = 293.448054089928, Press = -3.85401313879661
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 
   15000    -3140.314    -3140.314   -3214.3406   -3214.3406    286.49063    286.49063    44645.192    44645.192    6.3516372    6.3516372 
   16000   -3135.0825   -3135.0825   -3211.5649   -3211.5649    295.99504    295.99504    44585.142    44585.142    356.83551    356.83551 
Loop time of 173.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.313 hours/ns, 5.750 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.95     | 172.95     | 172.95     |   0.0 | 99.44
Neigh   | 0.47731    | 0.47731    | 0.47731    |   0.0 |  0.27
Comm    | 0.08958    | 0.08958    | 0.08958    |   0.0 |  0.05
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.35081    | 0.35081    | 0.35081    |   0.0 |  0.20
Other   |            | 0.0555     |            |       |  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:      121164.0 ave      121164 max      121164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121164
Ave neighs/atom = 60.582000
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 = 293.269228146818, Press = -1.6065026460359
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 
   16000   -3135.0825   -3135.0825   -3211.5649   -3211.5649    295.99504    295.99504    44585.142    44585.142    356.83551    356.83551 
   17000   -3137.2881   -3137.2881   -3212.5051   -3212.5051    291.09768    291.09768    44725.293    44725.293    -95.95115    -95.95115 
Loop time of 173.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.306 hours/ns, 5.750 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.93     | 172.93     | 172.93     |   0.0 | 99.44
Neigh   | 0.47655    | 0.47655    | 0.47655    |   0.0 |  0.27
Comm    | 0.090001   | 0.090001   | 0.090001   |   0.0 |  0.05
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.34958    | 0.34958    | 0.34958    |   0.0 |  0.20
Other   |            | 0.05551    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3323.00 ave        3323 max        3323 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:      121026.0 ave      121026 max      121026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121026
Ave neighs/atom = 60.513000
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 = 293.194460184758, Press = 0.589557895447949
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 
   17000   -3137.2881   -3137.2881   -3212.5051   -3212.5051    291.09768    291.09768    44725.293    44725.293    -95.95115    -95.95115 
   18000   -3137.2092   -3137.2092   -3214.1021   -3214.1021    297.58346    297.58346    44986.299    44986.299   -813.69868   -813.69868 
Loop time of 173.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.246 hours/ns, 5.758 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.71     | 172.71     | 172.71     |   0.0 | 99.44
Neigh   | 0.47692    | 0.47692    | 0.47692    |   0.0 |  0.27
Comm    | 0.089536   | 0.089536   | 0.089536   |   0.0 |  0.05
Output  | 0.00015356 | 0.00015356 | 0.00015356 |   0.0 |  0.00
Modify  | 0.35005    | 0.35005    | 0.35005    |   0.0 |  0.20
Other   |            | 0.05494    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3231.00 ave        3231 max        3231 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:      120670.0 ave      120670 max      120670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120670
Ave neighs/atom = 60.335000
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 = 293.222735356758, Press = -2.90390537832468
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   -3137.2092   -3137.2092   -3214.1021   -3214.1021    297.58346    297.58346    44986.299    44986.299   -813.69868   -813.69868 
   19000   -3139.3227   -3139.3227   -3214.5461   -3214.5461    291.12239    291.12239    44567.832    44567.832    235.35906    235.35906 
Loop time of 173.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.256 hours/ns, 5.756 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.73     | 172.73     | 172.73     |   0.0 | 99.43
Neigh   | 0.49821    | 0.49821    | 0.49821    |   0.0 |  0.29
Comm    | 0.090076   | 0.090076   | 0.090076   |   0.0 |  0.05
Output  | 0.00015606 | 0.00015606 | 0.00015606 |   0.0 |  0.00
Modify  | 0.34989    | 0.34989    | 0.34989    |   0.0 |  0.20
Other   |            | 0.05563    |            |       |  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:      121040.0 ave      121040 max      121040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121040
Ave neighs/atom = 60.520000
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 = 293.025954692895, Press = -3.92613837337164
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 
   19000   -3139.3227   -3139.3227   -3214.5461   -3214.5461    291.12239    291.12239    44567.832    44567.832    235.35906    235.35906 
   20000   -3134.8292   -3134.8292    -3212.998    -3212.998     302.5214     302.5214    44577.659    44577.659    344.03146    344.03146 
Loop time of 174.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.355 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.08     | 173.08     | 173.08     |   0.0 | 99.43
Neigh   | 0.49808    | 0.49808    | 0.49808    |   0.0 |  0.29
Comm    | 0.090285   | 0.090285   | 0.090285   |   0.0 |  0.05
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.35009    | 0.35009    | 0.35009    |   0.0 |  0.20
Other   |            | 0.05513    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3298.00 ave        3298 max        3298 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:      121184.0 ave      121184 max      121184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121184
Ave neighs/atom = 60.592000
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 = 293.053980802748, Press = -0.542749679146184
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 
   20000   -3134.8292   -3134.8292    -3212.998    -3212.998     302.5214     302.5214    44577.659    44577.659    344.03146    344.03146 
   21000   -3139.3712   -3139.3712   -3213.8556   -3213.8556    288.26233    288.26233    44668.226    44668.226   -74.999172   -74.999172 
Loop time of 173.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.278 hours/ns, 5.754 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.83     | 172.83     | 172.83     |   0.0 | 99.44
Neigh   | 0.47648    | 0.47648    | 0.47648    |   0.0 |  0.27
Comm    | 0.089735   | 0.089735   | 0.089735   |   0.0 |  0.05
Output  | 0.0001874  | 0.0001874  | 0.0001874  |   0.0 |  0.00
Modify  | 0.34981    | 0.34981    | 0.34981    |   0.0 |  0.20
Other   |            | 0.05527    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3305.00 ave        3305 max        3305 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 = 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 = 293.196009003187, Press = 0.335046503087748
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   -3139.3712   -3139.3712   -3213.8556   -3213.8556    288.26233    288.26233    44668.226    44668.226   -74.999172   -74.999172 
   22000   -3136.9771   -3136.9771    -3212.728    -3212.728      293.164      293.164    44880.239    44880.239   -525.69534   -525.69534 
Loop time of 173.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.255 hours/ns, 5.756 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.75     | 172.75     | 172.75     |   0.0 | 99.44
Neigh   | 0.47639    | 0.47639    | 0.47639    |   0.0 |  0.27
Comm    | 0.089889   | 0.089889   | 0.089889   |   0.0 |  0.05
Output  | 0.00018985 | 0.00018985 | 0.00018985 |   0.0 |  0.00
Modify  | 0.34989    | 0.34989    | 0.34989    |   0.0 |  0.20
Other   |            | 0.05492    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3304.00 ave        3304 max        3304 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:      120972.0 ave      120972 max      120972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120972
Ave neighs/atom = 60.486000
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 = 293.077910569373, Press = -2.46316977434542
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   -3136.9771   -3136.9771    -3212.728    -3212.728      293.164      293.164    44880.239    44880.239   -525.69534   -525.69534 
   23000   -3140.8974   -3140.8974   -3214.5751   -3214.5751    285.14017    285.14017    44541.988    44541.988    233.19344    233.19344 
Loop time of 180.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.099 hours/ns, 5.545 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    | 179.35     | 179.35     | 179.35     |   0.0 | 99.44
Neigh   | 0.48697    | 0.48697    | 0.48697    |   0.0 |  0.27
Comm    | 0.092122   | 0.092122   | 0.092122   |   0.0 |  0.05
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.36859    | 0.36859    | 0.36859    |   0.0 |  0.20
Other   |            | 0.05602    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3328.00 ave        3328 max        3328 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:      121078.0 ave      121078 max      121078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121078
Ave neighs/atom = 60.539000
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 = 292.936446515924, Press = -2.50993246187006
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   -3140.8974   -3140.8974   -3214.5751   -3214.5751    285.14017    285.14017    44541.988    44541.988    233.19344    233.19344 
   24000     -3135.11     -3135.11    -3212.692    -3212.692    300.25056    300.25056    44522.859    44522.859    511.82529    511.82529 
Loop time of 175.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.635 hours/ns, 5.711 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    | 174.08     | 174.08     | 174.08     |   0.0 | 99.43
Neigh   | 0.50455    | 0.50455    | 0.50455    |   0.0 |  0.29
Comm    | 0.091226   | 0.091226   | 0.091226   |   0.0 |  0.05
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.35266    | 0.35266    | 0.35266    |   0.0 |  0.20
Other   |            | 0.05449    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3323.00 ave        3323 max        3323 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:      121332.0 ave      121332 max      121332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121332
Ave neighs/atom = 60.666000
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 = 293.0129054027, Press = 0.725129836148043
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 
   24000     -3135.11     -3135.11    -3212.692    -3212.692    300.25056    300.25056    44522.859    44522.859    511.82529    511.82529 
   25000   -3137.5404   -3137.5404    -3213.151    -3213.151    292.62076    292.62076    44813.209    44813.209     -357.232     -357.232 
Loop time of 174.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.471 hours/ns, 5.731 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    | 173.52     | 173.52     | 173.52     |   0.0 | 99.44
Neigh   | 0.48054    | 0.48054    | 0.48054    |   0.0 |  0.28
Comm    | 0.089531   | 0.089531   | 0.089531   |   0.0 |  0.05
Output  | 0.00018899 | 0.00018899 | 0.00018899 |   0.0 |  0.00
Modify  | 0.35195    | 0.35195    | 0.35195    |   0.0 |  0.20
Other   |            | 0.05466    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 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:      120950.0 ave      120950 max      120950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120950
Ave neighs/atom = 60.475000
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 = 292.90565242879, Press = 1.16555101005557
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 
   25000   -3137.5404   -3137.5404    -3213.151    -3213.151    292.62076    292.62076    44813.209    44813.209     -357.232     -357.232 
   26000    -3139.543    -3139.543   -3216.0726   -3216.0726    296.17714    296.17714    44712.774    44712.774   -200.40857   -200.40857 
Loop time of 174.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.415 hours/ns, 5.737 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    | 173.32     | 173.32     | 173.32     |   0.0 | 99.44
Neigh   | 0.47956    | 0.47956    | 0.47956    |   0.0 |  0.28
Comm    | 0.090323   | 0.090323   | 0.090323   |   0.0 |  0.05
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.35074    | 0.35074    | 0.35074    |   0.0 |  0.20
Other   |            | 0.05478    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 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:      120990.0 ave      120990 max      120990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120990
Ave neighs/atom = 60.495000
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 = 292.883400943632, Press = -1.69855875182216
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 
   26000    -3139.543    -3139.543   -3216.0726   -3216.0726    296.17714    296.17714    44712.774    44712.774   -200.40857   -200.40857 
   27000   -3134.4163   -3134.4163   -3212.8444   -3212.8444    303.52507    303.52507    44765.619    44765.619   -159.47174   -159.47174 
Loop time of 174.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.469 hours/ns, 5.731 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    | 173.51     | 173.51     | 173.51     |   0.0 | 99.44
Neigh   | 0.47945    | 0.47945    | 0.47945    |   0.0 |  0.27
Comm    | 0.090588   | 0.090588   | 0.090588   |   0.0 |  0.05
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.3516     | 0.3516     | 0.3516     |   0.0 |  0.20
Other   |            | 0.05459    |            |       |  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:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
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 = 292.908770059775, Press = -2.04478636349349
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   -3134.4163   -3134.4163   -3212.8444   -3212.8444    303.52507    303.52507    44765.619    44765.619   -159.47174   -159.47174 
   28000   -3138.1706   -3138.1706   -3215.1009   -3215.1009     297.7285     297.7285    44474.001    44474.001    500.93582    500.93582 
Loop time of 177.966 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.435 hours/ns, 5.619 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    | 176.95     | 176.95     | 176.95     |   0.0 | 99.43
Neigh   | 0.50761    | 0.50761    | 0.50761    |   0.0 |  0.29
Comm    | 0.092149   | 0.092149   | 0.092149   |   0.0 |  0.05
Output  | 0.00018701 | 0.00018701 | 0.00018701 |   0.0 |  0.00
Modify  | 0.36173    | 0.36173    | 0.36173    |   0.0 |  0.20
Other   |            | 0.05507    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3305.00 ave        3305 max        3305 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:      121170.0 ave      121170 max      121170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121170
Ave neighs/atom = 60.585000
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 = 292.969994077733, Press = -1.34279339518788
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 
   28000   -3138.1706   -3138.1706   -3215.1009   -3215.1009     297.7285     297.7285    44474.001    44474.001    500.93582    500.93582 
   29000   -3138.9892   -3138.9892   -3215.1842   -3215.1842    294.88235    294.88235    44609.814    44609.814    114.00402    114.00402 
Loop time of 202.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.185 hours/ns, 4.944 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    | 201.15     | 201.15     | 201.15     |   0.0 | 99.45
Neigh   | 0.51649    | 0.51649    | 0.51649    |   0.0 |  0.26
Comm    | 0.10153    | 0.10153    | 0.10153    |   0.0 |  0.05
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.43244    | 0.43244    | 0.43244    |   0.0 |  0.21
Other   |            | 0.05903    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3359.00 ave        3359 max        3359 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:      121132.0 ave      121132 max      121132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121132
Ave neighs/atom = 60.566000
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 = 293.044661567455, Press = 0.41703986643167
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   -3138.9892   -3138.9892   -3215.1842   -3215.1842    294.88235    294.88235    44609.814    44609.814    114.00402    114.00402 
   30000   -3138.1836   -3138.1836   -3213.5807   -3213.5807    291.79472    291.79472    44829.426    44829.426    -390.0239    -390.0239 
Loop time of 203.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.503 hours/ns, 4.916 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    | 202.27     | 202.27     | 202.27     |   0.0 | 99.44
Neigh   | 0.54655    | 0.54655    | 0.54655    |   0.0 |  0.27
Comm    | 0.10366    | 0.10366    | 0.10366    |   0.0 |  0.05
Output  | 0.00015957 | 0.00015957 | 0.00015957 |   0.0 |  0.00
Modify  | 0.43413    | 0.43413    | 0.43413    |   0.0 |  0.21
Other   |            | 0.06034    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3298.00 ave        3298 max        3298 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 = 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 = 293.042181900659, Press = -0.206288587406994
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 
   30000   -3138.1836   -3138.1836   -3213.5807   -3213.5807    291.79472    291.79472    44829.426    44829.426    -390.0239    -390.0239 
   31000   -3138.4834   -3138.4834   -3213.6668   -3213.6668    290.96753    290.96753    44850.048    44850.048   -484.44814   -484.44814 
Loop time of 190.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.455 ns/day, 52.785 hours/ns, 5.262 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    | 188.95     | 188.95     | 188.95     |   0.0 | 99.44
Neigh   | 0.52382    | 0.52382    | 0.52382    |   0.0 |  0.28
Comm    | 0.098331   | 0.098331   | 0.098331   |   0.0 |  0.05
Output  | 0.00021372 | 0.00021372 | 0.00021372 |   0.0 |  0.00
Modify  | 0.39452    | 0.39452    | 0.39452    |   0.0 |  0.21
Other   |            | 0.05676    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3266.00 ave        3266 max        3266 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:      120848.0 ave      120848 max      120848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120848
Ave neighs/atom = 60.424000
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 = 293.005513485954, Press = -2.32380309332693
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   -3138.4834   -3138.4834   -3213.6668   -3213.6668    290.96753    290.96753    44850.048    44850.048   -484.44814   -484.44814 
   32000    -3135.602    -3135.602   -3212.6665   -3212.6665     298.2478     298.2478    44572.545    44572.545    332.74277    332.74277 
Loop time of 202.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.297 hours/ns, 4.934 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    | 201.55     | 201.55     | 201.55     |   0.0 | 99.45
Neigh   | 0.52108    | 0.52108    | 0.52108    |   0.0 |  0.26
Comm    | 0.10363    | 0.10363    | 0.10363    |   0.0 |  0.05
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.43552    | 0.43552    | 0.43552    |   0.0 |  0.21
Other   |            | 0.06142    |            |       |  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:      121066.0 ave      121066 max      121066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121066
Ave neighs/atom = 60.533000
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 = 293.02732842681, Press = -1.21248637762886
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    -3135.602    -3135.602   -3212.6665   -3212.6665     298.2478     298.2478    44572.545    44572.545    332.74277    332.74277 
   33000    -3139.366    -3139.366   -3214.6381   -3214.6381    291.31064    291.31064    44628.361    44628.361    73.456381    73.456381 
Loop time of 203.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.409 hours/ns, 4.924 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.94     | 201.94     | 201.94     |   0.0 | 99.44
Neigh   | 0.54205    | 0.54205    | 0.54205    |   0.0 |  0.27
Comm    | 0.10163    | 0.10163    | 0.10163    |   0.0 |  0.05
Output  | 0.0002365  | 0.0002365  | 0.0002365  |   0.0 |  0.00
Modify  | 0.42847    | 0.42847    | 0.42847    |   0.0 |  0.21
Other   |            | 0.06106    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      121028.0 ave      121028 max      121028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121028
Ave neighs/atom = 60.514000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
44683.918853515

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0