# 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.86696694791317*${_u_distance}
variable latticeconst_converted equal 2.86696694791317*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86696694791317
Lattice spacing in x,y,z = 2.8669669 2.8669669 2.8669669
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 (28.669669 28.669669 28.669669)
  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 (28.669669 28.669669 28.669669)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23565.0333387724 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7943.6608   -7943.6608   -8009.0725   -8009.0725       253.15       253.15    23565.033    23565.033     2964.861     2964.861 
    1000   -8007.7152   -8007.7152   -8073.4308   -8073.4308    254.32595    254.32595    21497.225    21497.225    270.52976    270.52976 
Loop time of 33.0212 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.617 ns/day, 9.173 hours/ns, 30.284 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    | 32.298     | 32.298     | 32.298     |   0.0 | 97.81
Neigh   | 0.14619    | 0.14619    | 0.14619    |   0.0 |  0.44
Comm    | 0.13454    | 0.13454    | 0.13454    |   0.0 |  0.41
Output  | 0.00019636 | 0.00019636 | 0.00019636 |   0.0 |  0.00
Modify  | 0.37501    | 0.37501    | 0.37501    |   0.0 |  1.14
Other   |            | 0.06704    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 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:      334382.0 ave      334382 max      334382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334382
Ave neighs/atom = 167.19100
Neighbor list builds = 3
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8007.7152   -8007.7152   -8073.4308   -8073.4308    254.32595    254.32595    21497.225    21497.225    270.52976    270.52976 
    2000   -8046.2485   -8046.2485   -8112.5447   -8112.5447    256.57296    256.57296     21531.36     21531.36   -1884.5518   -1884.5518 
Loop time of 31.8406 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.845 hours/ns, 31.406 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.208     | 31.208     | 31.208     |   0.0 | 98.01
Neigh   | 0.095373   | 0.095373   | 0.095373   |   0.0 |  0.30
Comm    | 0.12477    | 0.12477    | 0.12477    |   0.0 |  0.39
Output  | 0.00018466 | 0.00018466 | 0.00018466 |   0.0 |  0.00
Modify  | 0.34714    | 0.34714    | 0.34714    |   0.0 |  1.09
Other   |            | 0.06521    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 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:      332800.0 ave      332800 max      332800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332800
Ave neighs/atom = 166.40000
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8046.2485   -8046.2485   -8112.5447   -8112.5447    256.57296    256.57296     21531.36     21531.36   -1884.5518   -1884.5518 
    3000   -8053.2516   -8053.2516    -8120.621    -8120.621    260.72651    260.72651     21476.11     21476.11     920.0419     920.0419 
Loop time of 31.9871 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.885 hours/ns, 31.263 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    | 31.402     | 31.402     | 31.402     |   0.0 | 98.17
Neigh   | 0.047261   | 0.047261   | 0.047261   |   0.0 |  0.15
Comm    | 0.1242     | 0.1242     | 0.1242     |   0.0 |  0.39
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.34788    | 0.34788    | 0.34788    |   0.0 |  1.09
Other   |            | 0.06549    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 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:      333386.0 ave      333386 max      333386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333386
Ave neighs/atom = 166.69300
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 = 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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8053.2516   -8053.2516    -8120.621    -8120.621    260.72651    260.72651     21476.11     21476.11     920.0419     920.0419 
    4000   -8054.2531   -8054.2531   -8120.1847   -8120.1847    255.16223    255.16223    21490.755    21490.755   -910.60883   -910.60883 
Loop time of 33.6164 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.570 ns/day, 9.338 hours/ns, 29.747 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    | 33.057     | 33.057     | 33.057     |   0.0 | 98.34
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1285     | 0.1285     | 0.1285     |   0.0 |  0.38
Output  | 0.00018663 | 0.00018663 | 0.00018663 |   0.0 |  0.00
Modify  | 0.3646     | 0.3646     | 0.3646     |   0.0 |  1.08
Other   |            | 0.06588    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      334140.0 ave      334140 max      334140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334140
Ave neighs/atom = 167.07000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8054.2531   -8054.2531   -8120.1847   -8120.1847    255.16223    255.16223    21490.755    21490.755   -910.60883   -910.60883 
    5000    -8057.092    -8057.092   -8120.9499   -8120.9499    247.13669    247.13669    21465.135    21465.135    881.14167    881.14167 
Loop time of 32.5176 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.033 hours/ns, 30.753 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.971     | 31.971     | 31.971     |   0.0 | 98.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12365    | 0.12365    | 0.12365    |   0.0 |  0.38
Output  | 0.00016832 | 0.00016832 | 0.00016832 |   0.0 |  0.00
Modify  | 0.35684    | 0.35684    | 0.35684    |   0.0 |  1.10
Other   |            | 0.06601    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      333520.0 ave      333520 max      333520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333520
Ave neighs/atom = 166.76000
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 = 247.655081080626, Press = 99.8610625431478
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -8057.092    -8057.092   -8120.9499   -8120.9499    247.13669    247.13669    21465.135    21465.135    881.14167    881.14167 
    6000   -8053.9854   -8053.9854    -8120.162    -8120.162    256.11003    256.11003    21479.134    21479.134    11.938654    11.938654 
Loop time of 32.2962 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.971 hours/ns, 30.963 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.73      | 31.73      | 31.73      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12573    | 0.12573    | 0.12573    |   0.0 |  0.39
Output  | 0.00015093 | 0.00015093 | 0.00015093 |   0.0 |  0.00
Modify  | 0.37415    | 0.37415    | 0.37415    |   0.0 |  1.16
Other   |            | 0.06624    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5461.00 ave        5461 max        5461 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:      333882.0 ave      333882 max      333882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333882
Ave neighs/atom = 166.94100
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 = 251.266621063778, Press = -4.62929198363887
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8053.9854   -8053.9854    -8120.162    -8120.162    256.11003    256.11003    21479.134    21479.134    11.938654    11.938654 
    7000   -8054.4492   -8054.4492   -8120.0046   -8120.0046    253.70635    253.70635     21508.03     21508.03   -1909.2636   -1909.2636 
Loop time of 32.3223 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.978 hours/ns, 30.938 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.76      | 31.76      | 31.76      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12566    | 0.12566    | 0.12566    |   0.0 |  0.39
Output  | 0.00015232 | 0.00015232 | 0.00015232 |   0.0 |  0.00
Modify  | 0.37045    | 0.37045    | 0.37045    |   0.0 |  1.15
Other   |            | 0.06565    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      333608.0 ave      333608 max      333608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333608
Ave neighs/atom = 166.80400
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 = 251.849411174779, Press = -4.21399138617542
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8054.4492   -8054.4492   -8120.0046   -8120.0046    253.70635    253.70635     21508.03     21508.03   -1909.2636   -1909.2636 
    8000   -8057.4826   -8057.4826    -8120.952    -8120.952    245.63345    245.63345      21483.9      21483.9   -664.24122   -664.24122 
Loop time of 32.7035 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.084 hours/ns, 30.578 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    | 32.136     | 32.136     | 32.136     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12685    | 0.12685    | 0.12685    |   0.0 |  0.39
Output  | 0.00015727 | 0.00015727 | 0.00015727 |   0.0 |  0.00
Modify  | 0.37522    | 0.37522    | 0.37522    |   0.0 |  1.15
Other   |            | 0.06566    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 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:      333264.0 ave      333264 max      333264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333264
Ave neighs/atom = 166.63200
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 = 252.186533872068, Press = -11.3070677256165
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8057.4826   -8057.4826    -8120.952    -8120.952    245.63345    245.63345      21483.9      21483.9   -664.24122   -664.24122 
    9000   -8052.9932   -8052.9932   -8118.9912   -8118.9912    255.41921    255.41921    21508.579    21508.579   -1171.1335   -1171.1335 
Loop time of 32.7628 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.101 hours/ns, 30.522 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    | 32.196     | 32.196     | 32.196     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12494    | 0.12494    | 0.12494    |   0.0 |  0.38
Output  | 0.00015204 | 0.00015204 | 0.00015204 |   0.0 |  0.00
Modify  | 0.3758     | 0.3758     | 0.3758     |   0.0 |  1.15
Other   |            | 0.06579    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 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:      333596.0 ave      333596 max      333596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333596
Ave neighs/atom = 166.79800
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 = 252.008778033349, Press = -7.80561034441563
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8052.9932   -8052.9932   -8118.9912   -8118.9912    255.41921    255.41921    21508.579    21508.579   -1171.1335   -1171.1335 
   10000   -8052.2367   -8052.2367   -8118.7633   -8118.7633    257.46462    257.46462    21491.296    21491.296     206.3445     206.3445 
Loop time of 33.3986 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.587 ns/day, 9.277 hours/ns, 29.941 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    | 32.817     | 32.817     | 32.817     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12869    | 0.12869    | 0.12869    |   0.0 |  0.39
Output  | 0.00015085 | 0.00015085 | 0.00015085 |   0.0 |  0.00
Modify  | 0.38605    | 0.38605    | 0.38605    |   0.0 |  1.16
Other   |            | 0.06682    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 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:      333248.0 ave      333248 max      333248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333248
Ave neighs/atom = 166.62400
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 = 252.297424016349, Press = 7.6520007496488
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8052.2367   -8052.2367   -8118.7633   -8118.7633    257.46462    257.46462    21491.296    21491.296     206.3445     206.3445 
   11000   -8052.4632   -8052.4632   -8119.2173   -8119.2173    258.34529    258.34529    21468.622    21468.622    1723.0172    1723.0172 
Loop time of 33.101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.610 ns/day, 9.195 hours/ns, 30.211 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    | 32.528     | 32.528     | 32.528     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12643    | 0.12643    | 0.12643    |   0.0 |  0.38
Output  | 0.00019579 | 0.00019579 | 0.00019579 |   0.0 |  0.00
Modify  | 0.38009    | 0.38009    | 0.38009    |   0.0 |  1.15
Other   |            | 0.06611    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 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:      333396.0 ave      333396 max      333396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333396
Ave neighs/atom = 166.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 = 252.814786121746, Press = 10.4882927443941
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8052.4632   -8052.4632   -8119.2173   -8119.2173    258.34529    258.34529    21468.622    21468.622    1723.0172    1723.0172 
   12000   -8056.7191   -8056.7191   -8121.6175   -8121.6175     251.1637     251.1637    21477.034    21477.034   -112.12857   -112.12857 
Loop time of 33.2935 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.595 ns/day, 9.248 hours/ns, 30.036 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    | 32.717     | 32.717     | 32.717     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12754    | 0.12754    | 0.12754    |   0.0 |  0.38
Output  | 0.00015196 | 0.00015196 | 0.00015196 |   0.0 |  0.00
Modify  | 0.38257    | 0.38257    | 0.38257    |   0.0 |  1.15
Other   |            | 0.0664     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      333680.0 ave      333680 max      333680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333680
Ave neighs/atom = 166.84000
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 = 252.791324349338, Press = 6.83778221957685
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8056.7191   -8056.7191   -8121.6175   -8121.6175     251.1637     251.1637    21477.034    21477.034   -112.12857   -112.12857 
   13000   -8052.6462   -8052.6462   -8118.5782   -8118.5782    255.16368    255.16368    21494.157    21494.157   -778.94222   -778.94222 
Loop time of 32.7608 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.100 hours/ns, 30.524 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    | 32.193     | 32.193     | 32.193     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12596    | 0.12596    | 0.12596    |   0.0 |  0.38
Output  | 0.00019102 | 0.00019102 | 0.00019102 |   0.0 |  0.00
Modify  | 0.37574    | 0.37574    | 0.37574    |   0.0 |  1.15
Other   |            | 0.06579    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      333516.0 ave      333516 max      333516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333516
Ave neighs/atom = 166.75800
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 = 252.781988382429, Press = 1.22852705571937
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8052.6462   -8052.6462   -8118.5782   -8118.5782    255.16368    255.16368    21494.157    21494.157   -778.94222   -778.94222 
   14000     -8054.82     -8054.82   -8119.0747   -8119.0747    248.67206    248.67206    21481.431    21481.431   -365.89579   -365.89579 
Loop time of 33.333 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.592 ns/day, 9.259 hours/ns, 30.000 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    | 32.756     | 32.756     | 32.756     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12814    | 0.12814    | 0.12814    |   0.0 |  0.38
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.38242    | 0.38242    | 0.38242    |   0.0 |  1.15
Other   |            | 0.06619    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 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:      333116.0 ave      333116 max      333116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333116
Ave neighs/atom = 166.55800
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 = 252.559990704183, Press = 1.20518161900969
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000     -8054.82     -8054.82   -8119.0747   -8119.0747    248.67206    248.67206    21481.431    21481.431   -365.89579   -365.89579 
   15000   -8055.8905   -8055.8905   -8121.0404   -8121.0404     252.1368     252.1368    21497.456    21497.456   -1952.4634   -1952.4634 
Loop time of 32.9493 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.153 hours/ns, 30.350 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    | 32.382     | 32.382     | 32.382     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.38
Output  | 0.00019742 | 0.00019742 | 0.00019742 |   0.0 |  0.00
Modify  | 0.37575    | 0.37575    | 0.37575    |   0.0 |  1.14
Other   |            | 0.06544    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 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:      333706.0 ave      333706 max      333706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333706
Ave neighs/atom = 166.85300
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 = 252.565028522683, Press = 2.90754655910536
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8055.8905   -8055.8905   -8121.0404   -8121.0404     252.1368     252.1368    21497.456    21497.456   -1952.4634   -1952.4634 
   16000    -8053.233    -8053.233    -8117.893    -8117.893    250.24113    250.24113     21533.28     21533.28   -1942.8492   -1942.8492 
Loop time of 33.5406 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.576 ns/day, 9.317 hours/ns, 29.815 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    | 32.959     | 32.959     | 32.959     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12898    | 0.12898    | 0.12898    |   0.0 |  0.38
Output  | 0.00019677 | 0.00019677 | 0.00019677 |   0.0 |  0.00
Modify  | 0.38635    | 0.38635    | 0.38635    |   0.0 |  1.15
Other   |            | 0.06608    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      333152.0 ave      333152 max      333152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333152
Ave neighs/atom = 166.57600
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 = 252.442427026964, Press = -0.967792467007492
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -8053.233    -8053.233    -8117.893    -8117.893    250.24113    250.24113     21533.28     21533.28   -1942.8492   -1942.8492 
   17000   -8055.3159   -8055.3159    -8118.667    -8118.667    245.17533    245.17533    21494.629    21494.629   -751.30728   -751.30728 
Loop time of 32.4761 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.021 hours/ns, 30.792 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    | 31.915     | 31.915     | 31.915     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12459    | 0.12459    | 0.12459    |   0.0 |  0.38
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.37052    | 0.37052    | 0.37052    |   0.0 |  1.14
Other   |            | 0.06611    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      332804.0 ave      332804 max      332804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332804
Ave neighs/atom = 166.40200
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 = 252.487867354651, Press = 0.0121599383775835
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8055.3159   -8055.3159    -8118.667    -8118.667    245.17533    245.17533    21494.629    21494.629   -751.30728   -751.30728 
   18000   -8052.6577   -8052.6577    -8117.267    -8117.267    250.04493    250.04493    21498.873    21498.873    -617.8438    -617.8438 
Loop time of 33.8731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.551 ns/day, 9.409 hours/ns, 29.522 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    | 33.287     | 33.287     | 33.287     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1283     | 0.1283     | 0.1283     |   0.0 |  0.38
Output  | 0.00015514 | 0.00015514 | 0.00015514 |   0.0 |  0.00
Modify  | 0.39093    | 0.39093    | 0.39093    |   0.0 |  1.15
Other   |            | 0.06673    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 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:      333238.0 ave      333238 max      333238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333238
Ave neighs/atom = 166.61900
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 = 252.50083517183, Press = -2.71057790704533
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8052.6577   -8052.6577    -8117.267    -8117.267    250.04493    250.04493    21498.873    21498.873    -617.8438    -617.8438 
   19000    -8054.298    -8054.298   -8119.4063   -8119.4063    251.97574    251.97574    21449.226    21449.226    2506.2869    2506.2869 
Loop time of 33.8848 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.550 ns/day, 9.412 hours/ns, 29.512 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    | 33.3       | 33.3       | 33.3       |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12881    | 0.12881    | 0.12881    |   0.0 |  0.38
Output  | 0.00015681 | 0.00015681 | 0.00015681 |   0.0 |  0.00
Modify  | 0.38909    | 0.38909    | 0.38909    |   0.0 |  1.15
Other   |            | 0.06674    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 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:      333486.0 ave      333486 max      333486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333486
Ave neighs/atom = 166.74300
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 = 252.681019245299, Press = -4.35146752489406
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -8054.298    -8054.298   -8119.4063   -8119.4063    251.97574    251.97574    21449.226    21449.226    2506.2869    2506.2869 
   20000   -8054.2928   -8054.2928    -8120.861    -8120.861    257.62584    257.62584    21488.217    21488.217   -396.38896   -396.38896 
Loop time of 33.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.582 ns/day, 9.296 hours/ns, 29.881 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    | 32.888     | 32.888     | 32.888     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1288     | 0.1288     | 0.1288     |   0.0 |  0.38
Output  | 0.00019048 | 0.00019048 | 0.00019048 |   0.0 |  0.00
Modify  | 0.38371    | 0.38371    | 0.38371    |   0.0 |  1.15
Other   |            | 0.06576    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 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:      334068.0 ave      334068 max      334068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334068
Ave neighs/atom = 167.03400
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 = 252.752680390575, Press = -0.555897051315226
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8054.2928   -8054.2928    -8120.861    -8120.861    257.62584    257.62584    21488.217    21488.217   -396.38896   -396.38896 
   21000   -8056.2101   -8056.2101   -8120.7427   -8120.7427    249.74775    249.74775     21437.34     21437.34    3184.5801    3184.5801 
Loop time of 34.3077 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.518 ns/day, 9.530 hours/ns, 29.148 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    | 33.714     | 33.714     | 33.714     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13071    | 0.13071    | 0.13071    |   0.0 |  0.38
Output  | 0.0002008  | 0.0002008  | 0.0002008  |   0.0 |  0.00
Modify  | 0.39583    | 0.39583    | 0.39583    |   0.0 |  1.15
Other   |            | 0.06652    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 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:      333288.0 ave      333288 max      333288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333288
Ave neighs/atom = 166.64400
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 = 252.695563325319, Press = 1.33999130487469
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8056.2101   -8056.2101   -8120.7427   -8120.7427    249.74775    249.74775     21437.34     21437.34    3184.5801    3184.5801 
   22000   -8053.3605   -8053.3605   -8120.5505   -8120.5505    260.03213    260.03213    21512.704    21512.704   -2076.7913   -2076.7913 
Loop time of 33.7473 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.560 ns/day, 9.374 hours/ns, 29.632 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    | 33.17      | 33.17      | 33.17      |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12822    | 0.12822    | 0.12822    |   0.0 |  0.38
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.38348    | 0.38348    | 0.38348    |   0.0 |  1.14
Other   |            | 0.06523    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      334296.0 ave      334296 max      334296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334296
Ave neighs/atom = 167.14800
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 = 252.700083586289, Press = -2.15893780158178
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8053.3605   -8053.3605   -8120.5505   -8120.5505    260.03213    260.03213    21512.704    21512.704   -2076.7913   -2076.7913 
   23000   -8055.8289   -8055.8289   -8120.8664   -8120.8664    251.70174    251.70174    21466.718    21466.718    1493.2488    1493.2488 
Loop time of 33.8325 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.554 ns/day, 9.398 hours/ns, 29.557 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    | 33.249     | 33.249     | 33.249     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12847    | 0.12847    | 0.12847    |   0.0 |  0.38
Output  | 0.00015244 | 0.00015244 | 0.00015244 |   0.0 |  0.00
Modify  | 0.38881    | 0.38881    | 0.38881    |   0.0 |  1.15
Other   |            | 0.06591    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      332990.0 ave      332990 max      332990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332990
Ave neighs/atom = 166.49500
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 = 252.603855889751, Press = 2.02175528130476
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8055.8289   -8055.8289   -8120.8664   -8120.8664    251.70174    251.70174    21466.718    21466.718    1493.2488    1493.2488 
   24000   -8051.8387   -8051.8387    -8116.652    -8116.652    250.83433    250.83433     21469.04     21469.04    2764.5432    2764.5432 
Loop time of 32.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.081 hours/ns, 30.589 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    | 32.124     | 32.124     | 32.124     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.38
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.37545    | 0.37545    | 0.37545    |   0.0 |  1.15
Other   |            | 0.06565    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 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:      333898.0 ave      333898 max      333898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333898
Ave neighs/atom = 166.94900
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 = 252.626914894834, Press = 1.687846162839
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8051.8387   -8051.8387    -8116.652    -8116.652    250.83433    250.83433     21469.04     21469.04    2764.5432    2764.5432 
   25000   -8054.3768   -8054.3768   -8119.9598   -8119.9598    253.81302    253.81302    21466.334    21466.334    2013.5044    2013.5044 
Loop time of 32.8727 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.131 hours/ns, 30.420 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.301     | 32.301     | 32.301     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12711    | 0.12711    | 0.12711    |   0.0 |  0.39
Output  | 0.00019737 | 0.00019737 | 0.00019737 |   0.0 |  0.00
Modify  | 0.37779    | 0.37779    | 0.37779    |   0.0 |  1.15
Other   |            | 0.06618    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5464.00 ave        5464 max        5464 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:      333868.0 ave      333868 max      333868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333868
Ave neighs/atom = 166.93400
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 = 252.741676635932, Press = 3.05330789455848
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8054.3768   -8054.3768   -8119.9598   -8119.9598    253.81302    253.81302    21466.334    21466.334    2013.5044    2013.5044 
   26000    -8055.842    -8055.842   -8119.4661   -8119.4661    246.23191    246.23191    21496.436    21496.436   -318.93295   -318.93295 
Loop time of 33.3012 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.595 ns/day, 9.250 hours/ns, 30.029 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    | 32.724     | 32.724     | 32.724     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12779    | 0.12779    | 0.12779    |   0.0 |  0.38
Output  | 0.00016606 | 0.00016606 | 0.00016606 |   0.0 |  0.00
Modify  | 0.38285    | 0.38285    | 0.38285    |   0.0 |  1.15
Other   |            | 0.06597    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      333636.0 ave      333636 max      333636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333636
Ave neighs/atom = 166.81800
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 = 252.787046834874, Press = 0.980253322536906
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -8055.842    -8055.842   -8119.4661   -8119.4661    246.23191    246.23191    21496.436    21496.436   -318.93295   -318.93295 
   27000   -8055.5988   -8055.5988    -8119.884    -8119.884    248.79025    248.79025    21504.838    21504.838   -1694.4539   -1694.4539 
Loop time of 32.6177 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.649 ns/day, 9.060 hours/ns, 30.658 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    | 32.052     | 32.052     | 32.052     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.39
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.37339    | 0.37339    | 0.37339    |   0.0 |  1.14
Other   |            | 0.06621    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 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:      333602.0 ave      333602 max      333602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333602
Ave neighs/atom = 166.80100
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 = 252.661553870111, Press = 0.277191711660489
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8055.5988   -8055.5988    -8119.884    -8119.884    248.79025    248.79025    21504.838    21504.838   -1694.4539   -1694.4539 
   28000   -8053.8461   -8053.8461   -8119.7316   -8119.7316    254.98377    254.98377    21492.568    21492.568   -532.58093   -532.58093 
Loop time of 34.0748 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.536 ns/day, 9.465 hours/ns, 29.347 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    | 33.489     | 33.489     | 33.489     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13006    | 0.13006    | 0.13006    |   0.0 |  0.38
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.38887    | 0.38887    | 0.38887    |   0.0 |  1.14
Other   |            | 0.06653    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 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:      333194.0 ave      333194 max      333194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333194
Ave neighs/atom = 166.59700
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 = 252.675518143522, Press = -0.36805968478098
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8053.8461   -8053.8461   -8119.7316   -8119.7316    254.98377    254.98377    21492.568    21492.568   -532.58093   -532.58093 
   29000   -8053.4105   -8053.4105   -8119.1711   -8119.1711    254.50052    254.50052     21467.39     21467.39    2294.2633    2294.2633 
Loop time of 32.6976 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.083 hours/ns, 30.583 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    | 32.133     | 32.133     | 32.133     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12502    | 0.12502    | 0.12502    |   0.0 |  0.38
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.37357    | 0.37357    | 0.37357    |   0.0 |  1.14
Other   |            | 0.06597    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 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:      333434.0 ave      333434 max      333434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333434
Ave neighs/atom = 166.71700
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 = 252.672915804477, Press = -0.374255956909451
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8053.4105   -8053.4105   -8119.1711   -8119.1711    254.50052    254.50052     21467.39     21467.39    2294.2633    2294.2633 
   30000    -8054.466    -8054.466   -8119.0239   -8119.0239    249.84572    249.84572    21484.684    21484.684    601.18971    601.18971 
Loop time of 33.1863 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.603 ns/day, 9.218 hours/ns, 30.133 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    | 32.613     | 32.613     | 32.613     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12664    | 0.12664    | 0.12664    |   0.0 |  0.38
Output  | 0.00016054 | 0.00016054 | 0.00016054 |   0.0 |  0.00
Modify  | 0.38103    | 0.38103    | 0.38103    |   0.0 |  1.15
Other   |            | 0.06598    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      333776.0 ave      333776 max      333776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333776
Ave neighs/atom = 166.88800
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 = 252.640594355557, Press = 0.311258605029319
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -8054.466    -8054.466   -8119.0239   -8119.0239    249.84572    249.84572    21484.684    21484.684    601.18971    601.18971 
   31000   -8054.5311   -8054.5311   -8119.3612   -8119.3612    250.89932    250.89932    21487.987    21487.987   -57.643301   -57.643301 
Loop time of 33.4198 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.585 ns/day, 9.283 hours/ns, 29.922 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    | 32.844     | 32.844     | 32.844     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1268     | 0.1268     | 0.1268     |   0.0 |  0.38
Output  | 0.00015282 | 0.00015282 | 0.00015282 |   0.0 |  0.00
Modify  | 0.38271    | 0.38271    | 0.38271    |   0.0 |  1.15
Other   |            | 0.06618    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 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:      333496.0 ave      333496 max      333496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333496
Ave neighs/atom = 166.74800
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 = 252.668749422534, Press = 0.390015457421382
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8054.5311   -8054.5311   -8119.3612   -8119.3612    250.89932    250.89932    21487.987    21487.987   -57.643301   -57.643301 
   32000   -8054.6401   -8054.6401   -8120.4161   -8120.4161    254.55988    254.55988      21479.6      21479.6   -492.45181   -492.45181 
Loop time of 33.8555 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.552 ns/day, 9.404 hours/ns, 29.537 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    | 33.272     | 33.272     | 33.272     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12785    | 0.12785    | 0.12785    |   0.0 |  0.38
Output  | 0.00017247 | 0.00017247 | 0.00017247 |   0.0 |  0.00
Modify  | 0.38861    | 0.38861    | 0.38861    |   0.0 |  1.15
Other   |            | 0.06659    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      333486.0 ave      333486 max      333486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333486
Ave neighs/atom = 166.74300
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 = 252.734727089784, Press = -1.03650399865854
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8054.6401   -8054.6401   -8120.4161   -8120.4161    254.55988    254.55988      21479.6      21479.6   -492.45181   -492.45181 
   33000    -8054.336    -8054.336   -8118.4675   -8118.4675    248.19557    248.19557    21500.703    21500.703   -797.55021   -797.55021 
Loop time of 33.5171 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.578 ns/day, 9.310 hours/ns, 29.836 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    | 32.935     | 32.935     | 32.935     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12805    | 0.12805    | 0.12805    |   0.0 |  0.38
Output  | 0.00015567 | 0.00015567 | 0.00015567 |   0.0 |  0.00
Modify  | 0.38757    | 0.38757    | 0.38757    |   0.0 |  1.16
Other   |            | 0.0664     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      333508.0 ave      333508 max      333508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333508
Ave neighs/atom = 166.75400
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 = 252.848019425464, Press = 0.838469021278042
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -8054.336    -8054.336   -8118.4675   -8118.4675    248.19557    248.19557    21500.703    21500.703   -797.55021   -797.55021 
   34000    -8052.973    -8052.973   -8119.1506   -8119.1506    256.11399    256.11399    21513.989    21513.989   -1073.5008   -1073.5008 
Loop time of 34.7075 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.489 ns/day, 9.641 hours/ns, 28.812 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    | 34.109     | 34.109     | 34.109     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13173    | 0.13173    | 0.13173    |   0.0 |  0.38
Output  | 0.00015161 | 0.00015161 | 0.00015161 |   0.0 |  0.00
Modify  | 0.39898    | 0.39898    | 0.39898    |   0.0 |  1.15
Other   |            | 0.06719    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 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:      333198.0 ave      333198 max      333198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333198
Ave neighs/atom = 166.59900
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 = 252.878932331758, Press = 0.0964708683458941
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -8052.973    -8052.973   -8119.1506   -8119.1506    256.11399    256.11399    21513.989    21513.989   -1073.5008   -1073.5008 
   35000   -8058.0447   -8058.0447   -8120.5397   -8120.5397    241.86233    241.86233    21485.805    21485.805   -345.69182   -345.69182 
Loop time of 32.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.653 ns/day, 9.045 hours/ns, 30.711 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.996     | 31.996     | 31.996     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12548    | 0.12548    | 0.12548    |   0.0 |  0.39
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.37535    | 0.37535    | 0.37535    |   0.0 |  1.15
Other   |            | 0.06532    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      333088.0 ave      333088 max      333088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333088
Ave neighs/atom = 166.54400
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 = 252.824523834755, Press = -1.04575568621159
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8058.0447   -8058.0447   -8120.5397   -8120.5397    241.86233    241.86233    21485.805    21485.805   -345.69182   -345.69182 
   36000   -8053.9913   -8053.9913   -8119.5031   -8119.5031    253.53738    253.53738    21521.359    21521.359   -2377.6894   -2377.6894 
Loop time of 32.7631 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.101 hours/ns, 30.522 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    | 32.197     | 32.197     | 32.197     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12512    | 0.12512    | 0.12512    |   0.0 |  0.38
Output  | 0.00019421 | 0.00019421 | 0.00019421 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  1.14
Other   |            | 0.0658     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      333666.0 ave      333666 max      333666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333666
Ave neighs/atom = 166.83300
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 = 252.817230028737, Press = 0.610509807985904
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8053.9913   -8053.9913   -8119.5031   -8119.5031    253.53738    253.53738    21521.359    21521.359   -2377.6894   -2377.6894 
   37000   -8057.1179   -8057.1179   -8121.3295   -8121.3295    248.50557    248.50557    21521.192    21521.192   -2628.4096   -2628.4096 
Loop time of 32.3844 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.879 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.821     | 31.821     | 31.821     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.39
Output  | 0.00014951 | 0.00014951 | 0.00014951 |   0.0 |  0.00
Modify  | 0.37278    | 0.37278    | 0.37278    |   0.0 |  1.15
Other   |            | 0.06553    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      332634.0 ave      332634 max      332634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332634
Ave neighs/atom = 166.31700
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 = 252.750482934798, Press = 0.132980606233222
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8057.1179   -8057.1179   -8121.3295   -8121.3295    248.50557    248.50557    21521.192    21521.192   -2628.4096   -2628.4096 
   38000   -8056.6638   -8056.6638   -8121.4049   -8121.4049    250.55504    250.55504    21515.662    21515.662   -3134.0444   -3134.0444 
Loop time of 33.1689 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.214 hours/ns, 30.149 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    | 32.595     | 32.595     | 32.595     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12749    | 0.12749    | 0.12749    |   0.0 |  0.38
Output  | 0.00015142 | 0.00015142 | 0.00015142 |   0.0 |  0.00
Modify  | 0.38024    | 0.38024    | 0.38024    |   0.0 |  1.15
Other   |            | 0.06571    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 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:      333212.0 ave      333212 max      333212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333212
Ave neighs/atom = 166.60600
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 = 252.762528127884, Press = -1.62404124458838
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8056.6638   -8056.6638   -8121.4049   -8121.4049    250.55504    250.55504    21515.662    21515.662   -3134.0444   -3134.0444 
   39000   -8055.1595   -8055.1595   -8118.9387   -8118.9387    246.83238    246.83238    21489.047    21489.047    73.896015    73.896015 
Loop time of 32.0579 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.905 hours/ns, 31.194 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.501     | 31.501     | 31.501     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12319    | 0.12319    | 0.12319    |   0.0 |  0.38
Output  | 0.00015722 | 0.00015722 | 0.00015722 |   0.0 |  0.00
Modify  | 0.36826    | 0.36826    | 0.36826    |   0.0 |  1.15
Other   |            | 0.06575    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      333002.0 ave      333002 max      333002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333002
Ave neighs/atom = 166.50100
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 = 252.78893367879, Press = 0.411036307756034
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8055.1595   -8055.1595   -8118.9387   -8118.9387    246.83238    246.83238    21489.047    21489.047    73.896015    73.896015 
   40000    -8053.525    -8053.525   -8118.1433   -8118.1433    250.07952    250.07952    21493.861    21493.861    553.49056    553.49056 
Loop time of 32.9318 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.148 hours/ns, 30.366 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    | 32.361     | 32.361     | 32.361     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12646    | 0.12646    | 0.12646    |   0.0 |  0.38
Output  | 0.00015324 | 0.00015324 | 0.00015324 |   0.0 |  0.00
Modify  | 0.37862    | 0.37862    | 0.37862    |   0.0 |  1.15
Other   |            | 0.06593    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 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:      333292.0 ave      333292 max      333292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333292
Ave neighs/atom = 166.64600
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 = 252.866012016949, Press = 0.677037029675775
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -8053.525    -8053.525   -8118.1433   -8118.1433    250.07952    250.07952    21493.861    21493.861    553.49056    553.49056 
   41000   -8051.9541   -8051.9541   -8118.7596   -8118.7596     258.5444     258.5444    21500.147    21500.147    164.01572    164.01572 
Loop time of 33.0022 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.167 hours/ns, 30.301 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    | 32.43      | 32.43      | 32.43      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12695    | 0.12695    | 0.12695    |   0.0 |  0.38
Output  | 0.00015931 | 0.00015931 | 0.00015931 |   0.0 |  0.00
Modify  | 0.3791     | 0.3791     | 0.3791     |   0.0 |  1.15
Other   |            | 0.06593    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 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:      333598.0 ave      333598 max      333598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333598
Ave neighs/atom = 166.79900
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 = 252.876923654187, Press = 0.264603744322598
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8051.9541   -8051.9541   -8118.7596   -8118.7596     258.5444     258.5444    21500.147    21500.147    164.01572    164.01572 
   42000   -8056.0168   -8056.0168   -8121.2155   -8121.2155    252.32571    252.32571    21467.737    21467.737   -40.005684   -40.005684 
Loop time of 33.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.584 ns/day, 9.289 hours/ns, 29.905 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    | 32.859     | 32.859     | 32.859     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12843    | 0.12843    | 0.12843    |   0.0 |  0.38
Output  | 0.00019286 | 0.00019286 | 0.00019286 |   0.0 |  0.00
Modify  | 0.38528    | 0.38528    | 0.38528    |   0.0 |  1.15
Other   |            | 0.06635    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      333334.0 ave      333334 max      333334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333334
Ave neighs/atom = 166.66700
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 = 252.898209516999, Press = -0.221336167829723
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8056.0168   -8056.0168   -8121.2155   -8121.2155    252.32571    252.32571    21467.737    21467.737   -40.005684   -40.005684 
   43000   -8053.8791   -8053.8791   -8120.3671   -8120.3671    257.31549    257.31549    21482.534    21482.534    988.41139    988.41139 
Loop time of 32.1307 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.925 hours/ns, 31.123 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.571     | 31.571     | 31.571     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.39
Output  | 0.00015665 | 0.00015665 | 0.00015665 |   0.0 |  0.00
Modify  | 0.37019    | 0.37019    | 0.37019    |   0.0 |  1.15
Other   |            | 0.06525    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 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:      333994.0 ave      333994 max      333994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333994
Ave neighs/atom = 166.99700
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 = 252.906775537922, Press = -0.490502121486076
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8053.8791   -8053.8791   -8120.3671   -8120.3671    257.31549    257.31549    21482.534    21482.534    988.41139    988.41139 
   44000   -8053.9629   -8053.9629   -8119.4804   -8119.4804    253.55941    253.55941    21437.431    21437.431    3234.8769    3234.8769 
Loop time of 33.1353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.607 ns/day, 9.204 hours/ns, 30.179 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    | 32.557     | 32.557     | 32.557     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12862    | 0.12862    | 0.12862    |   0.0 |  0.39
Output  | 0.00014879 | 0.00014879 | 0.00014879 |   0.0 |  0.00
Modify  | 0.38251    | 0.38251    | 0.38251    |   0.0 |  1.15
Other   |            | 0.06716    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5458.00 ave        5458 max        5458 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:      333556.0 ave      333556 max      333556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333556
Ave neighs/atom = 166.77800
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 = 252.902409569027, Press = 0.662297413668589
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8053.9629   -8053.9629   -8119.4804   -8119.4804    253.55941    253.55941    21437.431    21437.431    3234.8769    3234.8769 
   45000   -8052.8747   -8052.8747   -8120.2301   -8120.2301    260.67213    260.67213    21464.734    21464.734    1984.4996    1984.4996 
Loop time of 32.9748 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.620 ns/day, 9.160 hours/ns, 30.326 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    | 32.404     | 32.404     | 32.404     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12636    | 0.12636    | 0.12636    |   0.0 |  0.38
Output  | 0.00020137 | 0.00020137 | 0.00020137 |   0.0 |  0.00
Modify  | 0.37798    | 0.37798    | 0.37798    |   0.0 |  1.15
Other   |            | 0.06597    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      334636.0 ave      334636 max      334636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334636
Ave neighs/atom = 167.31800
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 = 252.912426273927, Press = -0.534040348359396
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8052.8747   -8052.8747   -8120.2301   -8120.2301    260.67213    260.67213    21464.734    21464.734    1984.4996    1984.4996 
   46000   -8051.5747   -8051.5747   -8117.8605   -8117.8605    256.53284    256.53284    21472.379    21472.379    1380.4596    1380.4596 
Loop time of 33.8111 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.555 ns/day, 9.392 hours/ns, 29.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    | 33.224     | 33.224     | 33.224     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12978    | 0.12978    | 0.12978    |   0.0 |  0.38
Output  | 0.00019371 | 0.00019371 | 0.00019371 |   0.0 |  0.00
Modify  | 0.39068    | 0.39068    | 0.39068    |   0.0 |  1.16
Other   |            | 0.06642    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 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:      333870.0 ave      333870 max      333870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333870
Ave neighs/atom = 166.93500
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 = 252.912272703593, Press = -1.30937301962799
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.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8051.5747   -8051.5747   -8117.8605   -8117.8605    256.53284    256.53284    21472.379    21472.379    1380.4596    1380.4596 
   47000   -8054.8857   -8054.8857   -8120.4002   -8120.4002    253.54807    253.54807    21511.604    21511.604   -2151.6107   -2151.6107 
Loop time of 32.3164 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.977 hours/ns, 30.944 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.755     | 31.755     | 31.755     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12359    | 0.12359    | 0.12359    |   0.0 |  0.38
Output  | 0.00015159 | 0.00015159 | 0.00015159 |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  1.15
Other   |            | 0.06606    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 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:      333660.0 ave      333660 max      333660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333660
Ave neighs/atom = 166.83000
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
21485.9245499908

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0