# 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 2.938573218882084*${_u_distance}
variable latticeconst_converted equal 2.938573218882084*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.93857321888208
Lattice spacing in x,y,z = 2.9385732 2.9385732 2.9385732
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 (29.385732 29.385732 29.385732)
  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 (29.385732 29.385732 29.385732)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BelandTammMu_2017_FeNiCr__MO_715003088863_000
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 25375.2043761954 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 333.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "333.15 - 0.2"
variable      T_up  equal  "333.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_715003088863_000#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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -6959.3375   -6959.3375   -7045.4205   -7045.4205       333.15       333.15    25375.204    25375.204    3623.5224    3623.5224 
    1000   -7047.8699   -7047.8699   -7132.8273   -7132.8273    328.79391    328.79391    24121.984    24121.984   -384.54446   -384.54446 
Loop time of 30.9734 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.789 ns/day, 8.604 hours/ns, 32.286 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    | 30.236     | 30.236     | 30.236     |   0.0 | 97.62
Neigh   | 0.18973    | 0.18973    | 0.18973    |   0.0 |  0.61
Comm    | 0.12736    | 0.12736    | 0.12736    |   0.0 |  0.41
Output  | 0.00019677 | 0.00019677 | 0.00019677 |   0.0 |  0.00
Modify  | 0.35485    | 0.35485    | 0.35485    |   0.0 |  1.15
Other   |            | 0.06568    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5225.00 ave        5225 max        5225 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:      306782.0 ave      306782 max      306782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 306782
Ave neighs/atom = 153.39100
Neighbor list builds = 4
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7047.8699   -7047.8699   -7132.8273   -7132.8273    328.79391    328.79391    24121.984    24121.984   -384.54446   -384.54446 
    2000   -7096.8017   -7096.8017    -7182.829    -7182.829    332.93426    332.93426    23523.808    23523.808   -28.113598   -28.113598 
Loop time of 32.0843 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.693 ns/day, 8.912 hours/ns, 31.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    | 31.35      | 31.35      | 31.35      |   0.0 | 97.71
Neigh   | 0.19399    | 0.19399    | 0.19399    |   0.0 |  0.60
Comm    | 0.12283    | 0.12283    | 0.12283    |   0.0 |  0.38
Output  | 0.0001934  | 0.0001934  | 0.0001934  |   0.0 |  0.00
Modify  | 0.35327    | 0.35327    | 0.35327    |   0.0 |  1.10
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 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:      312982.0 ave      312982 max      312982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312982
Ave neighs/atom = 156.49100
Neighbor list builds = 4
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7096.8017   -7096.8017    -7182.829    -7182.829    332.93426    332.93426    23523.808    23523.808   -28.113598   -28.113598 
    3000   -7102.8669   -7102.8669    -7188.677    -7188.677    332.09431    332.09431    23565.113    23565.113   -1182.4984   -1182.4984 
Loop time of 31.0181 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.785 ns/day, 8.616 hours/ns, 32.239 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    | 30.397     | 30.397     | 30.397     |   0.0 | 98.00
Neigh   | 0.093121   | 0.093121   | 0.093121   |   0.0 |  0.30
Comm    | 0.11835    | 0.11835    | 0.11835    |   0.0 |  0.38
Output  | 0.0002338  | 0.0002338  | 0.0002338  |   0.0 |  0.00
Modify  | 0.34457    | 0.34457    | 0.34457    |   0.0 |  1.11
Other   |            | 0.06461    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5173.00 ave        5173 max        5173 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:      312232.0 ave      312232 max      312232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312232
Ave neighs/atom = 156.11600
Neighbor list builds = 2
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7102.8669   -7102.8669    -7188.677    -7188.677    332.09431    332.09431    23565.113    23565.113   -1182.4984   -1182.4984 
    4000   -7108.7613   -7108.7613     -7193.01     -7193.01    326.05132    326.05132    23461.118    23461.118    1282.3467    1282.3467 
Loop time of 31.1953 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.770 ns/day, 8.665 hours/ns, 32.056 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    | 30.568     | 30.568     | 30.568     |   0.0 | 97.99
Neigh   | 0.092364   | 0.092364   | 0.092364   |   0.0 |  0.30
Comm    | 0.12032    | 0.12032    | 0.12032    |   0.0 |  0.39
Output  | 0.00022558 | 0.00022558 | 0.00022558 |   0.0 |  0.00
Modify  | 0.34942    | 0.34942    | 0.34942    |   0.0 |  1.12
Other   |            | 0.06462    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 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:      311234.0 ave      311234 max      311234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311234
Ave neighs/atom = 155.61700
Neighbor list builds = 2
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7108.7613   -7108.7613     -7193.01     -7193.01    326.05132    326.05132    23461.118    23461.118    1282.3467    1282.3467 
    5000   -7111.0013   -7111.0013   -7195.9795   -7195.9795     328.8742     328.8742    23509.454    23509.454    1430.2887    1430.2887 
Loop time of 30.8825 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.578 hours/ns, 32.381 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    | 30.302     | 30.302     | 30.302     |   0.0 | 98.12
Neigh   | 0.046228   | 0.046228   | 0.046228   |   0.0 |  0.15
Comm    | 0.11954    | 0.11954    | 0.11954    |   0.0 |  0.39
Output  | 0.00016306 | 0.00016306 | 0.00016306 |   0.0 |  0.00
Modify  | 0.3496     | 0.3496     | 0.3496     |   0.0 |  1.13
Other   |            | 0.06532    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5139.00 ave        5139 max        5139 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:      310744.0 ave      310744 max      310744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310744
Ave neighs/atom = 155.37200
Neighbor list builds = 1
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 = 328.168062831973, Press = -1178.99522386106
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -7111.0013   -7111.0013   -7195.9795   -7195.9795     328.8742     328.8742    23509.454    23509.454    1430.2887    1430.2887 
    6000   -7104.3258   -7104.3258   -7194.4435   -7194.4435    348.76474    348.76474    23495.033    23495.033    2418.9957    2418.9957 
Loop time of 30.6982 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.814 ns/day, 8.527 hours/ns, 32.575 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    | 30.142     | 30.142     | 30.142     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11927    | 0.11927    | 0.11927    |   0.0 |  0.39
Output  | 0.00019872 | 0.00019872 | 0.00019872 |   0.0 |  0.00
Modify  | 0.37142    | 0.37142    | 0.37142    |   0.0 |  1.21
Other   |            | 0.06536    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 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:      311346.0 ave      311346 max      311346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311346
Ave neighs/atom = 155.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.051185382979, Press = -134.077866446339
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7104.3258   -7104.3258   -7194.4435   -7194.4435    348.76474    348.76474    23495.033    23495.033    2418.9957    2418.9957 
    7000   -7108.5308   -7108.5308    -7194.633    -7194.633    333.22462    333.22462    23531.119    23531.119   -712.18773   -712.18773 
Loop time of 32.2635 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.962 hours/ns, 30.995 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    | 31.696     | 31.696     | 31.696     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.38
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.37892    | 0.37892    | 0.37892    |   0.0 |  1.17
Other   |            | 0.066      |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5186.00 ave        5186 max        5186 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:      311502.0 ave      311502 max      311502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311502
Ave neighs/atom = 155.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.007745423212, Press = -45.8974389889964
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7108.5308   -7108.5308    -7194.633    -7194.633    333.22462    333.22462    23531.119    23531.119   -712.18773   -712.18773 
    8000   -7103.1402   -7103.1402   -7192.0748   -7192.0748    344.18582    344.18582    23568.181    23568.181   -3110.0124   -3110.0124 
Loop time of 32.3525 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.987 hours/ns, 30.910 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    | 31.786     | 31.786     | 31.786     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12232    | 0.12232    | 0.12232    |   0.0 |  0.38
Output  | 0.00015077 | 0.00015077 | 0.00015077 |   0.0 |  0.00
Modify  | 0.37904    | 0.37904    | 0.37904    |   0.0 |  1.17
Other   |            | 0.06503    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 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:      311260.0 ave      311260 max      311260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311260
Ave neighs/atom = 155.63000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.813879480838, Press = -40.3819060053598
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7103.1402   -7103.1402   -7192.0748   -7192.0748    344.18582    344.18582    23568.181    23568.181   -3110.0124   -3110.0124 
    9000   -7107.4123   -7107.4123   -7193.3037   -7193.3037    332.40894    332.40894    23499.733    23499.733    1455.9885    1455.9885 
Loop time of 31.1032 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.778 ns/day, 8.640 hours/ns, 32.151 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    | 30.55      | 30.55      | 30.55      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11978    | 0.11978    | 0.11978    |   0.0 |  0.39
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.36874    | 0.36874    | 0.36874    |   0.0 |  1.19
Other   |            | 0.06441    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 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:      310670.0 ave      310670 max      310670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310670
Ave neighs/atom = 155.33500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.947692923603, Press = -19.2940309451987
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7107.4123   -7107.4123   -7193.3037   -7193.3037    332.40894    332.40894    23499.733    23499.733    1455.9885    1455.9885 
   10000   -7110.4729   -7110.4729   -7196.5633   -7196.5633    333.17884    333.17884     23511.22     23511.22    784.52541    784.52541 
Loop time of 31.091 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.779 ns/day, 8.636 hours/ns, 32.164 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    | 30.532     | 30.532     | 30.532     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.39
Output  | 0.0001921  | 0.0001921  | 0.0001921  |   0.0 |  0.00
Modify  | 0.37292    | 0.37292    | 0.37292    |   0.0 |  1.20
Other   |            | 0.06498    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 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:      311500.0 ave      311500 max      311500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311500
Ave neighs/atom = 155.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.22945971125, Press = -11.8189826759891
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7110.4729   -7110.4729   -7196.5633   -7196.5633    333.17884    333.17884     23511.22     23511.22    784.52541    784.52541 
   11000   -7105.5371   -7105.5371    -7193.131    -7193.131    338.99754    338.99754    23541.553    23541.553   -2154.5248   -2154.5248 
Loop time of 30.5703 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.826 ns/day, 8.492 hours/ns, 32.712 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    | 30.025     | 30.025     | 30.025     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11841    | 0.11841    | 0.11841    |   0.0 |  0.39
Output  | 0.00019439 | 0.00019439 | 0.00019439 |   0.0 |  0.00
Modify  | 0.36175    | 0.36175    | 0.36175    |   0.0 |  1.18
Other   |            | 0.06485    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5170.00 ave        5170 max        5170 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:      311452.0 ave      311452 max      311452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311452
Ave neighs/atom = 155.72600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.947166603194, Press = -13.6703523081136
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7105.5371   -7105.5371    -7193.131    -7193.131    338.99754    338.99754    23541.553    23541.553   -2154.5248   -2154.5248 
   12000   -7108.5832   -7108.5832   -7193.2157   -7193.2157    327.53655    327.53655    23531.314    23531.314    -670.9402    -670.9402 
Loop time of 31.5711 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.737 ns/day, 8.770 hours/ns, 31.675 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    | 31.008     | 31.008     | 31.008     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.39
Output  | 0.00014886 | 0.00014886 | 0.00014886 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  1.19
Other   |            | 0.0658     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 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:      310964.0 ave      310964 max      310964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310964
Ave neighs/atom = 155.48200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.615313674488, Press = -10.7868787332845
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7108.5832   -7108.5832   -7193.2157   -7193.2157    327.53655    327.53655    23531.314    23531.314    -670.9402    -670.9402 
   13000   -7109.9504   -7109.9504   -7194.8632   -7194.8632    328.62113    328.62113    23589.286    23589.286   -4912.0466   -4912.0466 
Loop time of 31.3817 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.717 hours/ns, 31.866 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    | 30.815     | 30.815     | 30.815     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.39
Output  | 0.00019863 | 0.00019863 | 0.00019863 |   0.0 |  0.00
Modify  | 0.3778     | 0.3778     | 0.3778     |   0.0 |  1.20
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5163.00 ave        5163 max        5163 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:      311206.0 ave      311206 max      311206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311206
Ave neighs/atom = 155.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.427636852181, Press = -1.00534327476182
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7109.9504   -7109.9504   -7194.8632   -7194.8632    328.62113    328.62113    23589.286    23589.286   -4912.0466   -4912.0466 
   14000   -7108.9663   -7108.9663   -7194.8673   -7194.8673    332.44596    332.44596    23563.356    23563.356   -2315.5873   -2315.5873 
Loop time of 31.3246 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.701 hours/ns, 31.924 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    | 30.761     | 30.761     | 30.761     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12192    | 0.12192    | 0.12192    |   0.0 |  0.39
Output  | 0.0001977  | 0.0001977  | 0.0001977  |   0.0 |  0.00
Modify  | 0.37695    | 0.37695    | 0.37695    |   0.0 |  1.20
Other   |            | 0.06464    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5184.00 ave        5184 max        5184 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:      310404.0 ave      310404 max      310404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310404
Ave neighs/atom = 155.20200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.0039162425, Press = -4.74651353279388
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -7108.9663   -7108.9663   -7194.8673   -7194.8673    332.44596    332.44596    23563.356    23563.356   -2315.5873   -2315.5873 
   15000   -7108.8424   -7108.8424   -7196.4422   -7196.4422    339.02037    339.02037    23536.361    23536.361   -1175.1748   -1175.1748 
Loop time of 31.2937 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.693 hours/ns, 31.955 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    | 30.738     | 30.738     | 30.738     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12002    | 0.12002    | 0.12002    |   0.0 |  0.38
Output  | 0.00015212 | 0.00015212 | 0.00015212 |   0.0 |  0.00
Modify  | 0.37053    | 0.37053    | 0.37053    |   0.0 |  1.18
Other   |            | 0.06509    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5122.00 ave        5122 max        5122 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:      310856.0 ave      310856 max      310856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310856
Ave neighs/atom = 155.42800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.957488445809, Press = -3.6339654682677
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -7108.8424   -7108.8424   -7196.4422   -7196.4422    339.02037    339.02037    23536.361    23536.361   -1175.1748   -1175.1748 
   16000   -7111.1394   -7111.1394   -7194.0296   -7194.0296    320.79351    320.79351    23505.698    23505.698    1150.4676    1150.4676 
Loop time of 31.1599 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.773 ns/day, 8.656 hours/ns, 32.093 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    | 30.596     | 30.596     | 30.596     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.39
Output  | 0.00015246 | 0.00015246 | 0.00015246 |   0.0 |  0.00
Modify  | 0.37659    | 0.37659    | 0.37659    |   0.0 |  1.21
Other   |            | 0.0656     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 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:      311086.0 ave      311086 max      311086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311086
Ave neighs/atom = 155.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.61352759829, Press = -2.6329592799824
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7111.1394   -7111.1394   -7194.0296   -7194.0296    320.79351    320.79351    23505.698    23505.698    1150.4676    1150.4676 
   17000   -7107.9109   -7107.9109   -7193.7897   -7193.7897    332.36007    332.36007    23525.348    23525.348   -888.28203   -888.28203 
Loop time of 30.9708 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.790 ns/day, 8.603 hours/ns, 32.288 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    | 30.412     | 30.412     | 30.412     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12015    | 0.12015    | 0.12015    |   0.0 |  0.39
Output  | 0.00019185 | 0.00019185 | 0.00019185 |   0.0 |  0.00
Modify  | 0.37324    | 0.37324    | 0.37324    |   0.0 |  1.21
Other   |            | 0.06503    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 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:      311444.0 ave      311444 max      311444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311444
Ave neighs/atom = 155.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.641316172391, Press = -10.1133625831313
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7107.9109   -7107.9109   -7193.7897   -7193.7897    332.36007    332.36007    23525.348    23525.348   -888.28203   -888.28203 
   18000   -7110.5523   -7110.5523   -7195.0713   -7195.0713    327.09712    327.09712    23500.218    23500.218    940.06112    940.06112 
Loop time of 30.1508 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.866 ns/day, 8.375 hours/ns, 33.167 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    | 29.605     | 29.605     | 29.605     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11862    | 0.11862    | 0.11862    |   0.0 |  0.39
Output  | 0.00015116 | 0.00015116 | 0.00015116 |   0.0 |  0.00
Modify  | 0.36247    | 0.36247    | 0.36247    |   0.0 |  1.20
Other   |            | 0.06491    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5158.00 ave        5158 max        5158 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:      311432.0 ave      311432 max      311432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311432
Ave neighs/atom = 155.71600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.529321748924, Press = -3.78196721110657
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7110.5523   -7110.5523   -7195.0713   -7195.0713    327.09712    327.09712    23500.218    23500.218    940.06112    940.06112 
   19000   -7107.3874   -7107.3874   -7192.1058   -7192.1058    327.86873    327.86873     23551.71     23551.71   -1912.2093   -1912.2093 
Loop time of 30.2603 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.855 ns/day, 8.406 hours/ns, 33.047 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    | 29.714     | 29.714     | 29.714     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.39
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.36374    | 0.36374    | 0.36374    |   0.0 |  1.20
Other   |            | 0.06455    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 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:      311394.0 ave      311394 max      311394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311394
Ave neighs/atom = 155.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.585668661606, Press = -2.38049977058584
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7107.3874   -7107.3874   -7192.1058   -7192.1058    327.86873    327.86873     23551.71     23551.71   -1912.2093   -1912.2093 
   20000   -7104.9697   -7104.9697   -7191.8999   -7191.8999    336.42913    336.42913    23496.669    23496.669    1399.4315    1399.4315 
Loop time of 31.2752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.688 hours/ns, 31.974 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    | 30.716     | 30.716     | 30.716     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.39
Output  | 0.00016116 | 0.00016116 | 0.00016116 |   0.0 |  0.00
Modify  | 0.37433    | 0.37433    | 0.37433    |   0.0 |  1.20
Other   |            | 0.06432    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 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:      310734.0 ave      310734 max      310734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310734
Ave neighs/atom = 155.36700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.684403182542, Press = 1.1869637020922
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7104.9697   -7104.9697   -7191.8999   -7191.8999    336.42913    336.42913    23496.669    23496.669    1399.4315    1399.4315 
   21000   -7108.9083   -7108.9083   -7194.1456   -7194.1456    329.87699    329.87699    23500.277    23500.277    2334.6455    2334.6455 
Loop time of 31.3177 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.699 hours/ns, 31.931 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    | 30.758     | 30.758     | 30.758     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12054    | 0.12054    | 0.12054    |   0.0 |  0.38
Output  | 0.00025392 | 0.00025392 | 0.00025392 |   0.0 |  0.00
Modify  | 0.37344    | 0.37344    | 0.37344    |   0.0 |  1.19
Other   |            | 0.06593    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 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:      311972.0 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 155.98600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.914416608196, Press = 0.349621955146141
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7108.9083   -7108.9083   -7194.1456   -7194.1456    329.87699    329.87699    23500.277    23500.277    2334.6455    2334.6455 
   22000   -7105.1665   -7105.1665   -7192.2795   -7192.2795     337.1362     337.1362    23519.413    23519.413    292.89756    292.89756 
Loop time of 30.6974 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.815 ns/day, 8.527 hours/ns, 32.576 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    | 30.141     | 30.141     | 30.141     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12088    | 0.12088    | 0.12088    |   0.0 |  0.39
Output  | 0.00019122 | 0.00019122 | 0.00019122 |   0.0 |  0.00
Modify  | 0.37103    | 0.37103    | 0.37103    |   0.0 |  1.21
Other   |            | 0.06462    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 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:      311472.0 ave      311472 max      311472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311472
Ave neighs/atom = 155.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.024531971076, Press = -1.65385797316508
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7105.1665   -7105.1665   -7192.2795   -7192.2795     337.1362     337.1362    23519.413    23519.413    292.89756    292.89756 
   23000   -7107.6473   -7107.6473   -7193.7593   -7193.7593    333.26221    333.26221    23503.057    23503.057     1541.166     1541.166 
Loop time of 31.6053 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.779 hours/ns, 31.640 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    | 31.046     | 31.046     | 31.046     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12005    | 0.12005    | 0.12005    |   0.0 |  0.38
Output  | 0.00019739 | 0.00019739 | 0.00019739 |   0.0 |  0.00
Modify  | 0.37337    | 0.37337    | 0.37337    |   0.0 |  1.18
Other   |            | 0.06544    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 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:      311346.0 ave      311346 max      311346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311346
Ave neighs/atom = 155.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.050498877579, Press = 0.569567138021503
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7107.6473   -7107.6473   -7193.7593   -7193.7593    333.26221    333.26221    23503.057    23503.057     1541.166     1541.166 
   24000   -7110.2148   -7110.2148   -7195.8681   -7195.8681    331.48709    331.48709    23512.824    23512.824    936.97876    936.97876 
Loop time of 30.5283 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.830 ns/day, 8.480 hours/ns, 32.757 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    | 29.982     | 29.982     | 29.982     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11843    | 0.11843    | 0.11843    |   0.0 |  0.39
Output  | 0.00015457 | 0.00015457 | 0.00015457 |   0.0 |  0.00
Modify  | 0.36415    | 0.36415    | 0.36415    |   0.0 |  1.19
Other   |            | 0.06398    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 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:      311656.0 ave      311656 max      311656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311656
Ave neighs/atom = 155.82800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.156162307771, Press = -3.53154303503603
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7110.2148   -7110.2148   -7195.8681   -7195.8681    331.48709    331.48709    23512.824    23512.824    936.97876    936.97876 
   25000   -7107.0917   -7107.0917   -7194.3201   -7194.3201    337.58289    337.58289    23489.387    23489.387    1718.5967    1718.5967 
Loop time of 30.6673 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.519 hours/ns, 32.608 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    | 30.117     | 30.117     | 30.117     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11927    | 0.11927    | 0.11927    |   0.0 |  0.39
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.36675    | 0.36675    | 0.36675    |   0.0 |  1.20
Other   |            | 0.06464    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 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:      311166.0 ave      311166 max      311166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311166
Ave neighs/atom = 155.58300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.12859562015, Press = -4.69499406198881
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -7107.0917   -7107.0917   -7194.3201   -7194.3201    337.58289    337.58289    23489.387    23489.387    1718.5967    1718.5967 
   26000    -7109.895    -7109.895   -7194.7604   -7194.7604    328.43798    328.43798    23502.608    23502.608    40.249401    40.249401 
Loop time of 30.4867 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.834 ns/day, 8.469 hours/ns, 32.801 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    | 29.939     | 29.939     | 29.939     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11771    | 0.11771    | 0.11771    |   0.0 |  0.39
Output  | 0.00024647 | 0.00024647 | 0.00024647 |   0.0 |  0.00
Modify  | 0.36482    | 0.36482    | 0.36482    |   0.0 |  1.20
Other   |            | 0.06505    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 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:      311710.0 ave      311710 max      311710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311710
Ave neighs/atom = 155.85500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.98861198139, Press = -4.64130829996688
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -7109.895    -7109.895   -7194.7604   -7194.7604    328.43798    328.43798    23502.608    23502.608    40.249401    40.249401 
   27000   -7106.9518   -7106.9518   -7192.5194   -7192.5194    331.15568    331.15568    23572.836    23572.836   -3299.1233   -3299.1233 
Loop time of 30.4414 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.838 ns/day, 8.456 hours/ns, 32.850 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    | 29.895     | 29.895     | 29.895     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11759    | 0.11759    | 0.11759    |   0.0 |  0.39
Output  | 0.0001966  | 0.0001966  | 0.0001966  |   0.0 |  0.00
Modify  | 0.36397    | 0.36397    | 0.36397    |   0.0 |  1.20
Other   |            | 0.0649     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 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:      311686.0 ave      311686 max      311686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311686
Ave neighs/atom = 155.84300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.923241046426, Press = -5.18224078390288
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7106.9518   -7106.9518   -7192.5194   -7192.5194    331.15568    331.15568    23572.836    23572.836   -3299.1233   -3299.1233 
   28000   -7104.9217   -7104.9217   -7192.2577   -7192.2577    337.99927    337.99927    23558.522    23558.522   -2996.9797   -2996.9797 
Loop time of 31.2064 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.668 hours/ns, 32.045 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    | 30.647     | 30.647     | 30.647     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11956    | 0.11956    | 0.11956    |   0.0 |  0.38
Output  | 0.00020003 | 0.00020003 | 0.00020003 |   0.0 |  0.00
Modify  | 0.37499    | 0.37499    | 0.37499    |   0.0 |  1.20
Other   |            | 0.06509    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5138.00 ave        5138 max        5138 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:      310340.0 ave      310340 max      310340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310340
Ave neighs/atom = 155.17000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.866082204856, Press = -2.5054654887834
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7104.9217   -7104.9217   -7192.2577   -7192.2577    337.99927    337.99927    23558.522    23558.522   -2996.9797   -2996.9797 
   29000    -7110.332    -7110.332   -7195.6999   -7195.6999    330.38229    330.38229    23531.106    23531.106   -945.18235   -945.18235 
Loop time of 30.5465 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.828 ns/day, 8.485 hours/ns, 32.737 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    | 29.994     | 29.994     | 29.994     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11873    | 0.11873    | 0.11873    |   0.0 |  0.39
Output  | 0.00015597 | 0.00015597 | 0.00015597 |   0.0 |  0.00
Modify  | 0.36814    | 0.36814    | 0.36814    |   0.0 |  1.21
Other   |            | 0.06517    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 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:      310708.0 ave      310708 max      310708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310708
Ave neighs/atom = 155.35400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.940783972687, Press = -0.844194368336765
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -7110.332    -7110.332   -7195.6999   -7195.6999    330.38229    330.38229    23531.106    23531.106   -945.18235   -945.18235 
   30000   -7104.2413   -7104.2413   -7190.4846   -7190.4846    333.77028    333.77028    23505.014    23505.014    1415.1188    1415.1188 
Loop time of 30.6233 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.821 ns/day, 8.506 hours/ns, 32.655 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    | 30.072     | 30.072     | 30.072     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11932    | 0.11932    | 0.11932    |   0.0 |  0.39
Output  | 0.00019984 | 0.00019984 | 0.00019984 |   0.0 |  0.00
Modify  | 0.36729    | 0.36729    | 0.36729    |   0.0 |  1.20
Other   |            | 0.06452    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 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:      311164.0 ave      311164 max      311164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311164
Ave neighs/atom = 155.58200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.003902680477, Press = -1.86632055771893
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7104.2413   -7104.2413   -7190.4846   -7190.4846    333.77028    333.77028    23505.014    23505.014    1415.1188    1415.1188 
   31000   -7108.6501   -7108.6501   -7193.5967   -7193.5967    328.75229    328.75229    23501.555    23501.555    903.60566    903.60566 
Loop time of 30.5186 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.831 ns/day, 8.477 hours/ns, 32.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    | 29.975     | 29.975     | 29.975     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11783    | 0.11783    | 0.11783    |   0.0 |  0.39
Output  | 0.00019619 | 0.00019619 | 0.00019619 |   0.0 |  0.00
Modify  | 0.36101    | 0.36101    | 0.36101    |   0.0 |  1.18
Other   |            | 0.06439    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 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:      311172.0 ave      311172 max      311172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311172
Ave neighs/atom = 155.58600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.079491505247, Press = -2.67071233170942
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7108.6501   -7108.6501   -7193.5967   -7193.5967    328.75229    328.75229    23501.555    23501.555    903.60566    903.60566 
   32000   -7106.2127   -7106.2127   -7191.7883   -7191.7883     331.1866     331.1866    23517.117    23517.117    743.67101    743.67101 
Loop time of 30.931 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.793 ns/day, 8.592 hours/ns, 32.330 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    | 30.375     | 30.375     | 30.375     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11934    | 0.11934    | 0.11934    |   0.0 |  0.39
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.37171    | 0.37171    | 0.37171    |   0.0 |  1.20
Other   |            | 0.06479    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 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:      311806.0 ave      311806 max      311806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311806
Ave neighs/atom = 155.90300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.204931697482, Press = -2.73981407705523
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -7106.2127   -7106.2127   -7191.7883   -7191.7883     331.1866     331.1866    23517.117    23517.117    743.67101    743.67101 
   33000   -7106.0398   -7106.0398   -7194.6805   -7194.6805    343.04872    343.04872    23526.205    23526.205    172.48786    172.48786 
Loop time of 31.5601 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.767 hours/ns, 31.686 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    | 30.997     | 30.997     | 30.997     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.38
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.37625    | 0.37625    | 0.37625    |   0.0 |  1.19
Other   |            | 0.06547    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5163.00 ave        5163 max        5163 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:      311542.0 ave      311542 max      311542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311542
Ave neighs/atom = 155.77100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.245719961997, Press = -4.09162057886932
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -7106.0398   -7106.0398   -7194.6805   -7194.6805    343.04872    343.04872    23526.205    23526.205    172.48786    172.48786 
   34000   -7111.2189   -7111.2189   -7195.8349   -7195.8349    327.47292    327.47292    23512.227    23512.227   -241.88527   -241.88527 
Loop time of 30.8357 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.802 ns/day, 8.565 hours/ns, 32.430 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    | 30.284     | 30.284     | 30.284     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12022    | 0.12022    | 0.12022    |   0.0 |  0.39
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.36692    | 0.36692    | 0.36692    |   0.0 |  1.19
Other   |            | 0.06437    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5176.00 ave        5176 max        5176 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:      311384.0 ave      311384 max      311384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311384
Ave neighs/atom = 155.69200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.226218824591, Press = -7.00313376483534
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7111.2189   -7111.2189   -7195.8349   -7195.8349    327.47292    327.47292    23512.227    23512.227   -241.88527   -241.88527 
   35000   -7107.1857   -7107.1857   -7195.9416   -7195.9416    343.49475    343.49475     23574.77     23574.77   -4681.6903   -4681.6903 
Loop time of 31.2083 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.768 ns/day, 8.669 hours/ns, 32.043 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    | 30.64      | 30.64      | 30.64      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12179    | 0.12179    | 0.12179    |   0.0 |  0.39
Output  | 0.00014892 | 0.00014892 | 0.00014892 |   0.0 |  0.00
Modify  | 0.38139    | 0.38139    | 0.38139    |   0.0 |  1.22
Other   |            | 0.06495    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5152.00 ave        5152 max        5152 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:      311396.0 ave      311396 max      311396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311396
Ave neighs/atom = 155.69800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.191759470143, Press = -5.02306606746712
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -7107.1857   -7107.1857   -7195.9416   -7195.9416    343.49475    343.49475     23574.77     23574.77   -4681.6903   -4681.6903 
   36000   -7110.7196   -7110.7196   -7195.3517   -7195.3517    327.53487    327.53487    23571.535    23571.535   -3699.9331   -3699.9331 
Loop time of 30.8566 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.800 ns/day, 8.571 hours/ns, 32.408 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    | 30.302     | 30.302     | 30.302     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12019    | 0.12019    | 0.12019    |   0.0 |  0.39
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.36975    | 0.36975    | 0.36975    |   0.0 |  1.20
Other   |            | 0.06434    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 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:      310370.0 ave      310370 max      310370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310370
Ave neighs/atom = 155.18500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.147210077364, Press = -3.11230682449853
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7110.7196   -7110.7196   -7195.3517   -7195.3517    327.53487    327.53487    23571.535    23571.535   -3699.9331   -3699.9331 
   37000   -7107.2067   -7107.2067   -7193.2102   -7193.2102     332.8426     332.8426    23543.489    23543.489   -1863.6662   -1863.6662 
Loop time of 31.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.782 ns/day, 8.627 hours/ns, 32.200 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    | 30.497     | 30.497     | 30.497     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.39
Output  | 0.00015381 | 0.00015381 | 0.00015381 |   0.0 |  0.00
Modify  | 0.37326    | 0.37326    | 0.37326    |   0.0 |  1.20
Other   |            | 0.06482    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5158.00 ave        5158 max        5158 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:      310922.0 ave      310922 max      310922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310922
Ave neighs/atom = 155.46100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.122114212184, Press = -0.571124679406636
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7107.2067   -7107.2067   -7193.2102   -7193.2102     332.8426     332.8426    23543.489    23543.489   -1863.6662   -1863.6662 
   38000   -7109.0917   -7109.0917   -7194.8645   -7194.8645     331.9494     331.9494    23521.977    23521.977   -686.02507   -686.02507 
Loop time of 31.3962 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.721 hours/ns, 31.851 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    | 30.836     | 30.836     | 30.836     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12056    | 0.12056    | 0.12056    |   0.0 |  0.38
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.37463    | 0.37463    | 0.37463    |   0.0 |  1.19
Other   |            | 0.06468    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 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:      311006.0 ave      311006 max      311006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311006
Ave neighs/atom = 155.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.168559484627, Press = -0.7464075261394
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7109.0917   -7109.0917   -7194.8645   -7194.8645     331.9494     331.9494    23521.977    23521.977   -686.02507   -686.02507 
   39000   -7103.7547   -7103.7547   -7192.3552   -7192.3552    342.89301    342.89301    23522.146    23522.146    64.985045    64.985045 
Loop time of 31.1187 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.776 ns/day, 8.644 hours/ns, 32.135 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    | 30.562     | 30.562     | 30.562     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12035    | 0.12035    | 0.12035    |   0.0 |  0.39
Output  | 0.00019117 | 0.00019117 | 0.00019117 |   0.0 |  0.00
Modify  | 0.372      | 0.372      | 0.372      |   0.0 |  1.20
Other   |            | 0.06463    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5149.00 ave        5149 max        5149 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:      311270.0 ave      311270 max      311270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311270
Ave neighs/atom = 155.63500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.201275621881, Press = -1.58990058442344
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7103.7547   -7103.7547   -7192.3552   -7192.3552    342.89301    342.89301    23522.146    23522.146    64.985045    64.985045 
   40000    -7109.158    -7109.158   -7195.9045   -7195.9045     335.7182     335.7182    23510.687    23510.687     362.8325     362.8325 
Loop time of 30.5752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.826 ns/day, 8.493 hours/ns, 32.706 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    | 30.024     | 30.024     | 30.024     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11901    | 0.11901    | 0.11901    |   0.0 |  0.39
Output  | 0.00019952 | 0.00019952 | 0.00019952 |   0.0 |  0.00
Modify  | 0.36756    | 0.36756    | 0.36756    |   0.0 |  1.20
Other   |            | 0.06473    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 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:      311242.0 ave      311242 max      311242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311242
Ave neighs/atom = 155.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.25735999138, Press = -0.340395087190496
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -7109.158    -7109.158   -7195.9045   -7195.9045     335.7182     335.7182    23510.687    23510.687     362.8325     362.8325 
   41000   -7108.1463   -7108.1463    -7195.297    -7195.297    337.28241    337.28241    23491.741    23491.741    2449.7366    2449.7366 
Loop time of 30.6897 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.815 ns/day, 8.525 hours/ns, 32.584 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    | 30.139     | 30.139     | 30.139     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11832    | 0.11832    | 0.11832    |   0.0 |  0.39
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.36753    | 0.36753    | 0.36753    |   0.0 |  1.20
Other   |            | 0.06485    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5138.00 ave        5138 max        5138 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:      311350.0 ave      311350 max      311350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311350
Ave neighs/atom = 155.67500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.251546549235, Press = -0.624462807253796
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -7108.1463   -7108.1463    -7195.297    -7195.297    337.28241    337.28241    23491.741    23491.741    2449.7366    2449.7366 
   42000   -7107.9981   -7107.9981   -7193.1568   -7193.1568    329.57299    329.57299    23498.336    23498.336     1857.292     1857.292 
Loop time of 31.2759 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.688 hours/ns, 31.973 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    | 30.714     | 30.714     | 30.714     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.39
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.37576    | 0.37576    | 0.37576    |   0.0 |  1.20
Other   |            | 0.06499    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 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:      311622.0 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 155.81100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.154098633421, Press = -2.62410176634692
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7107.9981   -7107.9981   -7193.1568   -7193.1568    329.57299    329.57299    23498.336    23498.336     1857.292     1857.292 
   43000   -7110.9418   -7110.9418   -7194.7041   -7194.7041    324.16877    324.16877    23473.572    23473.572    3732.2995    3732.2995 
Loop time of 30.2473 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.856 ns/day, 8.402 hours/ns, 33.061 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    | 29.699     | 29.699     | 29.699     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11901    | 0.11901    | 0.11901    |   0.0 |  0.39
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.36436    | 0.36436    | 0.36436    |   0.0 |  1.20
Other   |            | 0.06453    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5169.00 ave        5169 max        5169 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:      311330.0 ave      311330 max      311330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311330
Ave neighs/atom = 155.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.135333240968, Press = -2.04861197901926
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -7110.9418   -7110.9418   -7194.7041   -7194.7041    324.16877    324.16877    23473.572    23473.572    3732.2995    3732.2995 
   44000   -7106.9722   -7106.9722   -7193.8898   -7193.8898    336.37985    336.37985    23511.206    23511.206    813.01998    813.01998 
Loop time of 31.2607 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.764 ns/day, 8.684 hours/ns, 31.989 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    | 30.699     | 30.699     | 30.699     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.39
Output  | 0.00015685 | 0.00015685 | 0.00015685 |   0.0 |  0.00
Modify  | 0.37429    | 0.37429    | 0.37429    |   0.0 |  1.20
Other   |            | 0.06564    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5173.00 ave        5173 max        5173 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:      312134.0 ave      312134 max      312134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312134
Ave neighs/atom = 156.06700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.121151931497, Press = -2.42910356983998
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7106.9722   -7106.9722   -7193.8898   -7193.8898    336.37985    336.37985    23511.206    23511.206    813.01998    813.01998 
   45000   -7109.9144   -7109.9144   -7194.8702   -7194.8702    328.78775    328.78775    23525.661    23525.661   -320.59828   -320.59828 
Loop time of 30.7717 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.808 ns/day, 8.548 hours/ns, 32.497 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    | 30.22      | 30.22      | 30.22      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11863    | 0.11863    | 0.11863    |   0.0 |  0.39
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.36772    | 0.36772    | 0.36772    |   0.0 |  1.19
Other   |            | 0.0649     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 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:      311308.0 ave      311308 max      311308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311308
Ave neighs/atom = 155.65400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.190644756711, Press = -3.95398547665489
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -7109.9144   -7109.9144   -7194.8702   -7194.8702    328.78775    328.78775    23525.661    23525.661   -320.59828   -320.59828 
   46000   -7107.6149   -7107.6149   -7194.6665   -7194.6665    336.89887    336.89887    23493.542    23493.542    1980.5749    1980.5749 
Loop time of 30.7878 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.806 ns/day, 8.552 hours/ns, 32.480 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    | 30.226     | 30.226     | 30.226     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12026    | 0.12026    | 0.12026    |   0.0 |  0.39
Output  | 0.00020037 | 0.00020037 | 0.00020037 |   0.0 |  0.00
Modify  | 0.37576    | 0.37576    | 0.37576    |   0.0 |  1.22
Other   |            | 0.06566    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 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:      311072.0 ave      311072 max      311072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311072
Ave neighs/atom = 155.53600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.176543778583, Press = -1.41527433046764
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7107.6149   -7107.6149   -7194.6665   -7194.6665    336.89887    336.89887    23493.542    23493.542    1980.5749    1980.5749 
   47000   -7107.0948   -7107.0948   -7195.6483   -7195.6483    342.71147    342.71147     23544.03     23544.03   -1487.5334   -1487.5334 
Loop time of 30.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.807 ns/day, 8.550 hours/ns, 32.488 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    | 30.224     | 30.224     | 30.224     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12028    | 0.12028    | 0.12028    |   0.0 |  0.39
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.37069    | 0.37069    | 0.37069    |   0.0 |  1.20
Other   |            | 0.06548    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 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:      311714.0 ave      311714 max      311714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311714
Ave neighs/atom = 155.85700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.131151258678, Press = -1.41201053403416
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -7107.0948   -7107.0948   -7195.6483   -7195.6483    342.71147    342.71147     23544.03     23544.03   -1487.5334   -1487.5334 
   48000   -7109.3796   -7109.3796   -7194.3575   -7194.3575    328.87307    328.87307     23539.26     23539.26   -1699.7251   -1699.7251 
Loop time of 30.3182 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.850 ns/day, 8.422 hours/ns, 32.983 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    | 29.772     | 29.772     | 29.772     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11858    | 0.11858    | 0.11858    |   0.0 |  0.39
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.36228    | 0.36228    | 0.36228    |   0.0 |  1.19
Other   |            | 0.06548    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 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:      311284.0 ave      311284 max      311284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311284
Ave neighs/atom = 155.64200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.110136556395, Press = -2.09958950902982
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -7109.3796   -7109.3796   -7194.3575   -7194.3575    328.87307    328.87307     23539.26     23539.26   -1699.7251   -1699.7251 
   49000   -7107.0284   -7107.0284   -7192.7026   -7192.7026    331.56792    331.56792    23510.239    23510.239   -96.349921   -96.349921 
Loop time of 30.7009 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.814 ns/day, 8.528 hours/ns, 32.572 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    | 30.148     | 30.148     | 30.148     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11844    | 0.11844    | 0.11844    |   0.0 |  0.39
Output  | 0.00014974 | 0.00014974 | 0.00014974 |   0.0 |  0.00
Modify  | 0.36894    | 0.36894    | 0.36894    |   0.0 |  1.20
Other   |            | 0.06545    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5133.00 ave        5133 max        5133 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:      311280.0 ave      311280 max      311280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311280
Ave neighs/atom = 155.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.122280883021, Press = -1.45810496857982
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7107.0284   -7107.0284   -7192.7026   -7192.7026    331.56792    331.56792    23510.239    23510.239   -96.349921   -96.349921 
   50000   -7108.5371   -7108.5371   -7194.6362   -7194.6362    333.21266    333.21266    23527.352    23527.352    -936.0195    -936.0195 
Loop time of 30.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.825 ns/day, 8.495 hours/ns, 32.699 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    | 30.028     | 30.028     | 30.028     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11894    | 0.11894    | 0.11894    |   0.0 |  0.39
Output  | 0.00015264 | 0.00015264 | 0.00015264 |   0.0 |  0.00
Modify  | 0.37096    | 0.37096    | 0.37096    |   0.0 |  1.21
Other   |            | 0.06443    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 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:      311252.0 ave      311252 max      311252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311252
Ave neighs/atom = 155.62600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.104397130154, Press = -1.59632527949387
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7108.5371   -7108.5371   -7194.6362   -7194.6362    333.21266    333.21266    23527.352    23527.352    -936.0195    -936.0195 
   51000   -7109.5673   -7109.5673   -7195.3173   -7195.3173    331.86137    331.86137     23524.38     23524.38   -631.84478   -631.84478 
Loop time of 30.9778 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.789 ns/day, 8.605 hours/ns, 32.281 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    | 30.424     | 30.424     | 30.424     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12019    | 0.12019    | 0.12019    |   0.0 |  0.39
Output  | 0.00015158 | 0.00015158 | 0.00015158 |   0.0 |  0.00
Modify  | 0.36894    | 0.36894    | 0.36894    |   0.0 |  1.19
Other   |            | 0.06462    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5180.00 ave        5180 max        5180 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:      311362.0 ave      311362 max      311362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311362
Ave neighs/atom = 155.68100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.110547840655, Press = -1.65509725311938
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -7109.5673   -7109.5673   -7195.3173   -7195.3173    331.86137    331.86137     23524.38     23524.38   -631.84478   -631.84478 
   52000   -7105.5793   -7105.5793   -7195.7961   -7195.7961    349.14847    349.14847    23516.333    23516.333   -98.174949   -98.174949 
Loop time of 31.2367 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.766 ns/day, 8.677 hours/ns, 32.014 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    | 30.671     | 30.671     | 30.671     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.39
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.37904    | 0.37904    | 0.37904    |   0.0 |  1.21
Other   |            | 0.06537    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 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:      311134.0 ave      311134 max      311134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311134
Ave neighs/atom = 155.56700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.127174981751, Press = -0.920123723943541
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7105.5793   -7105.5793   -7195.7961   -7195.7961    349.14847    349.14847    23516.333    23516.333   -98.174949   -98.174949 
   53000   -7108.7216   -7108.7216   -7194.6103   -7194.6103    332.39822    332.39822    23461.851    23461.851    3750.3461    3750.3461 
Loop time of 31.0423 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.783 ns/day, 8.623 hours/ns, 32.214 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    | 30.483     | 30.483     | 30.483     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.39
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.37348    | 0.37348    | 0.37348    |   0.0 |  1.20
Other   |            | 0.06479    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 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:      311380.0 ave      311380 max      311380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311380
Ave neighs/atom = 155.69000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152290385793, Press = -1.03557754263133
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7108.7216   -7108.7216   -7194.6103   -7194.6103    332.39822    332.39822    23461.851    23461.851    3750.3461    3750.3461 
   54000   -7106.9139   -7106.9139    -7195.341    -7195.341    342.22206    342.22206    23501.545    23501.545    1929.0031    1929.0031 
Loop time of 31.1163 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.777 ns/day, 8.643 hours/ns, 32.138 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    | 30.558     | 30.558     | 30.558     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.39
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.37126    | 0.37126    | 0.37126    |   0.0 |  1.19
Other   |            | 0.06534    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5181.00 ave        5181 max        5181 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:      311812.0 ave      311812 max      311812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311812
Ave neighs/atom = 155.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.158455374366, Press = -2.07529788112058
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7106.9139   -7106.9139    -7195.341    -7195.341    342.22206    342.22206    23501.545    23501.545    1929.0031    1929.0031 
   55000   -7110.5394   -7110.5394   -7195.9694   -7195.9694     330.6233     330.6233    23534.784    23534.784   -1502.7293   -1502.7293 
Loop time of 31.1779 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.661 hours/ns, 32.074 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    | 30.618     | 30.618     | 30.618     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12022    | 0.12022    | 0.12022    |   0.0 |  0.39
Output  | 0.00020584 | 0.00020584 | 0.00020584 |   0.0 |  0.00
Modify  | 0.37455    | 0.37455    | 0.37455    |   0.0 |  1.20
Other   |            | 0.06528    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 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:      311456.0 ave      311456 max      311456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311456
Ave neighs/atom = 155.72800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.130084233112, Press = -2.03548154511625
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7110.5394   -7110.5394   -7195.9694   -7195.9694     330.6233     330.6233    23534.784    23534.784   -1502.7293   -1502.7293 
   56000   -7106.3011   -7106.3011   -7194.5395   -7194.5395    341.49137    341.49137     23520.25     23520.25    294.11509    294.11509 
Loop time of 30.2729 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.854 ns/day, 8.409 hours/ns, 33.033 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    | 29.725     | 29.725     | 29.725     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1179     | 0.1179     | 0.1179     |   0.0 |  0.39
Output  | 0.00015281 | 0.00015281 | 0.00015281 |   0.0 |  0.00
Modify  | 0.36527    | 0.36527    | 0.36527    |   0.0 |  1.21
Other   |            | 0.06454    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 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:      311182.0 ave      311182 max      311182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311182
Ave neighs/atom = 155.59100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.061807335277, Press = -0.82183337956188
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -7106.3011   -7106.3011   -7194.5395   -7194.5395    341.49137    341.49137     23520.25     23520.25    294.11509    294.11509 
   57000   -7110.8353   -7110.8353   -7195.8736   -7195.8736    329.10698    329.10698    23530.144    23530.144   -1211.0815   -1211.0815 
Loop time of 30.0581 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.874 ns/day, 8.349 hours/ns, 33.269 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    | 29.515     | 29.515     | 29.515     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11662    | 0.11662    | 0.11662    |   0.0 |  0.39
Output  | 0.00015731 | 0.00015731 | 0.00015731 |   0.0 |  0.00
Modify  | 0.36108    | 0.36108    | 0.36108    |   0.0 |  1.20
Other   |            | 0.06498    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 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:      311438.0 ave      311438 max      311438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311438
Ave neighs/atom = 155.71900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.060371360313, Press = -1.32513739682707
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -7110.8353   -7110.8353   -7195.8736   -7195.8736    329.10698    329.10698    23530.144    23530.144   -1211.0815   -1211.0815 
   58000   -7108.3642   -7108.3642   -7194.7203   -7194.7203    334.20732    334.20732    23534.372    23534.372   -868.98111   -868.98111 
Loop time of 30.8757 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.577 hours/ns, 32.388 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    | 30.314     | 30.314     | 30.314     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.39
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.37509    | 0.37509    | 0.37509    |   0.0 |  1.21
Other   |            | 0.06512    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5152.00 ave        5152 max        5152 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:      311242.0 ave      311242 max      311242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0