# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.938573218882084*${_u_distance}
variable latticeconst_converted equal 2.938573218882084*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.93857321888208
Lattice spacing in x,y,z = 2.9385732 2.9385732 2.9385732
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (29.385732 29.385732 29.385732)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (29.385732 29.385732 29.385732)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Cr

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

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


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

variable temp_converted equal 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.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -6980.0088   -6980.0088   -7045.4205   -7045.4205       253.15       253.15    25375.204    25375.204    2753.4068    2753.4068 
    1000   -7088.2907   -7088.2907   -7152.3167   -7152.3167     247.7873     247.7873     24113.47     24113.47   -1853.1381   -1853.1381 
Loop time of 30.3137 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.850 ns/day, 8.420 hours/ns, 32.988 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.574     | 29.574     | 29.574     |   0.0 | 97.56
Neigh   | 0.19792    | 0.19792    | 0.19792    |   0.0 |  0.65
Comm    | 0.12507    | 0.12507    | 0.12507    |   0.0 |  0.41
Output  | 0.00019665 | 0.00019665 | 0.00019665 |   0.0 |  0.00
Modify  | 0.35168    | 0.35168    | 0.35168    |   0.0 |  1.16
Other   |            | 0.06457    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5228.00 ave        5228 max        5228 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:      306478.0 ave      306478 max      306478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 306478
Ave neighs/atom = 153.23900
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7088.2907   -7088.2907   -7152.3167   -7152.3167     247.7873     247.7873     24113.47     24113.47   -1853.1381   -1853.1381 
    2000   -7119.1079   -7119.1079   -7183.3763   -7183.3763    248.72512    248.72512    23626.498    23626.498    1552.1328    1552.1328 
Loop time of 30.9196 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.794 ns/day, 8.589 hours/ns, 32.342 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.244     | 30.244     | 30.244     |   0.0 | 97.81
Neigh   | 0.14267    | 0.14267    | 0.14267    |   0.0 |  0.46
Comm    | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.39
Output  | 0.00018861 | 0.00018861 | 0.00018861 |   0.0 |  0.00
Modify  | 0.34793    | 0.34793    | 0.34793    |   0.0 |  1.13
Other   |            | 0.0643     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5184.00 ave        5184 max        5184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310662.0 ave      310662 max      310662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310662
Ave neighs/atom = 155.33100
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7119.1079   -7119.1079   -7183.3763   -7183.3763    248.72512    248.72512    23626.498    23626.498    1552.1328    1552.1328 
    3000   -7142.0396   -7142.0396   -7205.2454   -7205.2454    244.61309    244.61309    23526.713    23526.713    1268.5606    1268.5606 
Loop time of 31.5516 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.764 hours/ns, 31.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.919     | 30.919     | 30.919     |   0.0 | 97.99
Neigh   | 0.096086   | 0.096086   | 0.096086   |   0.0 |  0.30
Comm    | 0.12037    | 0.12037    | 0.12037    |   0.0 |  0.38
Output  | 0.00018957 | 0.00018957 | 0.00018957 |   0.0 |  0.00
Modify  | 0.35171    | 0.35171    | 0.35171    |   0.0 |  1.11
Other   |            | 0.0645     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5166.00 ave        5166 max        5166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311380.0 ave      311380 max      311380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311380
Ave neighs/atom = 155.69000
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7142.0396   -7142.0396   -7205.2454   -7205.2454    244.61309    244.61309    23526.713    23526.713    1268.5606    1268.5606 
    4000   -7148.7152   -7148.7152   -7215.3625   -7215.3625    257.93202    257.93202    23486.471    23486.471   -178.45509   -178.45509 
Loop time of 30.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.799 ns/day, 8.574 hours/ns, 32.397 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.192     | 30.192     | 30.192     |   0.0 | 97.81
Neigh   | 0.14444    | 0.14444    | 0.14444    |   0.0 |  0.47
Comm    | 0.11951    | 0.11951    | 0.11951    |   0.0 |  0.39
Output  | 0.00019523 | 0.00019523 | 0.00019523 |   0.0 |  0.00
Modify  | 0.34725    | 0.34725    | 0.34725    |   0.0 |  1.12
Other   |            | 0.06404    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5191.00 ave        5191 max        5191 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:      312186.0 ave      312186 max      312186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312186
Ave neighs/atom = 156.09300
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7148.7152   -7148.7152   -7215.3625   -7215.3625    257.93202    257.93202    23486.471    23486.471   -178.45509   -178.45509 
    5000   -7151.3493   -7151.3493    -7216.006    -7216.006    250.22804    250.22804    23452.188    23452.188    341.62809    341.62809 
Loop time of 30.7137 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.532 hours/ns, 32.559 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.178     | 30.178     | 30.178     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11907    | 0.11907    | 0.11907    |   0.0 |  0.39
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.35116    | 0.35116    | 0.35116    |   0.0 |  1.14
Other   |            | 0.06511    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5179.00 ave        5179 max        5179 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:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 156.01200
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.168937596437, Press = 134.130383949322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -7151.3493   -7151.3493    -7216.006    -7216.006    250.22804    250.22804    23452.188    23452.188    341.62809    341.62809 
    6000   -7153.1284   -7153.1284   -7218.4611   -7218.4611    252.84427    252.84427    23463.401    23463.401     2480.032     2480.032 
Loop time of 30.4682 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.836 ns/day, 8.463 hours/ns, 32.821 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.92      | 29.92      | 29.92      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11896    | 0.11896    | 0.11896    |   0.0 |  0.39
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.36441    | 0.36441    | 0.36441    |   0.0 |  1.20
Other   |            | 0.06456    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5173.00 ave        5173 max        5173 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312422.0 ave      312422 max      312422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312422
Ave neighs/atom = 156.21100
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.425020053771, Press = -51.0818545272441
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7153.1284   -7153.1284   -7218.4611   -7218.4611    252.84427    252.84427    23463.401    23463.401     2480.032     2480.032 
    7000   -7149.8063   -7149.8063   -7215.8238   -7215.8238    255.49442    255.49442    23482.345    23482.345    636.82312    636.82312 
Loop time of 31.7534 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.820 hours/ns, 31.493 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.193     | 31.193     | 31.193     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.38
Output  | 0.00015269 | 0.00015269 | 0.00015269 |   0.0 |  0.00
Modify  | 0.3747     | 0.3747     | 0.3747     |   0.0 |  1.18
Other   |            | 0.06479    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5181.00 ave        5181 max        5181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312142.0 ave      312142 max      312142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312142
Ave neighs/atom = 156.07100
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.721760758684, Press = -15.6253832430999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7149.8063   -7149.8063   -7215.8238   -7215.8238    255.49442    255.49442    23482.345    23482.345    636.82312    636.82312 
    8000   -7149.7499   -7149.7499   -7215.6564   -7215.6564    255.06485    255.06485    23479.586    23479.586    473.77284    473.77284 
Loop time of 31.8024 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.834 hours/ns, 31.444 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.232     | 31.232     | 31.232     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.38
Output  | 0.00015365 | 0.00015365 | 0.00015365 |   0.0 |  0.00
Modify  | 0.38305    | 0.38305    | 0.38305    |   0.0 |  1.20
Other   |            | 0.0659     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312150.0 ave      312150 max      312150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312150
Ave neighs/atom = 156.07500
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 = 253.74931179971, Press = -12.528843459634
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7149.7499   -7149.7499   -7215.6564   -7215.6564    255.06485    255.06485    23479.586    23479.586    473.77284    473.77284 
    9000   -7148.4198   -7148.4198   -7216.6054   -7216.6054     263.8855     263.8855    23485.103    23485.103    740.11414    740.11414 
Loop time of 31.6664 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.728 ns/day, 8.796 hours/ns, 31.579 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.108     | 31.108     | 31.108     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12005    | 0.12005    | 0.12005    |   0.0 |  0.38
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.37362    | 0.37362    | 0.37362    |   0.0 |  1.18
Other   |            | 0.06465    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311938.0 ave      311938 max      311938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311938
Ave neighs/atom = 155.96900
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 = 253.789607886224, Press = 3.05084958444454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7148.4198   -7148.4198   -7216.6054   -7216.6054     263.8855     263.8855    23485.103    23485.103    740.11414    740.11414 
   10000   -7151.4242   -7151.4242   -7216.3359   -7216.3359    251.21503    251.21503    23505.679    23505.679   -1214.0818   -1214.0818 
Loop time of 31.1501 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.774 ns/day, 8.653 hours/ns, 32.103 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.591     | 30.591     | 30.591     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11997    | 0.11997    | 0.11997    |   0.0 |  0.39
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.37433    | 0.37433    | 0.37433    |   0.0 |  1.20
Other   |            | 0.0649     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5170.00 ave        5170 max        5170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311758.0 ave      311758 max      311758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311758
Ave neighs/atom = 155.87900
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 = 254.024590207509, Press = 1.40917403909216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7151.4242   -7151.4242   -7216.3359   -7216.3359    251.21503    251.21503    23505.679    23505.679   -1214.0818   -1214.0818 
   11000   -7152.9416   -7152.9416   -7216.0999   -7216.0999    244.42914    244.42914    23469.253    23469.253    1044.4153    1044.4153 
Loop time of 30.7416 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.811 ns/day, 8.539 hours/ns, 32.529 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.188     | 30.188     | 30.188     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11914    | 0.11914    | 0.11914    |   0.0 |  0.39
Output  | 0.00014892 | 0.00014892 | 0.00014892 |   0.0 |  0.00
Modify  | 0.36926    | 0.36926    | 0.36926    |   0.0 |  1.20
Other   |            | 0.0648     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5166.00 ave        5166 max        5166 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:      311866.0 ave      311866 max      311866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311866
Ave neighs/atom = 155.93300
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 = 254.016098778872, Press = 2.9306147745997
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7152.9416   -7152.9416   -7216.0999   -7216.0999    244.42914    244.42914    23469.253    23469.253    1044.4153    1044.4153 
   12000   -7148.0586   -7148.0586   -7214.9794   -7214.9794    258.99053    258.99053    23490.884    23490.884    144.62284    144.62284 
Loop time of 30.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.842 ns/day, 8.444 hours/ns, 32.896 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.851     | 29.851     | 29.851     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11888    | 0.11888    | 0.11888    |   0.0 |  0.39
Output  | 0.00020321 | 0.00020321 | 0.00020321 |   0.0 |  0.00
Modify  | 0.36459    | 0.36459    | 0.36459    |   0.0 |  1.20
Other   |            | 0.06442    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5142.00 ave        5142 max        5142 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:      311916.0 ave      311916 max      311916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311916
Ave neighs/atom = 155.95800
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 = 253.820979949457, Press = 4.87394562064053
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7148.0586   -7148.0586   -7214.9794   -7214.9794    258.99053    258.99053    23490.884    23490.884    144.62284    144.62284 
   13000    -7151.229    -7151.229    -7216.952    -7216.952    254.35478    254.35478     23493.28     23493.28   -50.911232   -50.911232 
Loop time of 31.5109 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.753 hours/ns, 31.735 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.951     | 30.951     | 30.951     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12002    | 0.12002    | 0.12002    |   0.0 |  0.38
Output  | 0.00018632 | 0.00018632 | 0.00018632 |   0.0 |  0.00
Modify  | 0.37492    | 0.37492    | 0.37492    |   0.0 |  1.19
Other   |            | 0.06526    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311794.0 ave      311794 max      311794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311794
Ave neighs/atom = 155.89700
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 = 253.866403708623, Press = 3.55567277847136
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -7151.229    -7151.229    -7216.952    -7216.952    254.35478    254.35478     23493.28     23493.28   -50.911232   -50.911232 
   14000   -7151.9691   -7151.9691   -7216.5018   -7216.5018    249.74797    249.74797    23472.458    23472.458    966.89979    966.89979 
Loop time of 30.3549 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.846 ns/day, 8.432 hours/ns, 32.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    | 29.811     | 29.811     | 29.811     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11714    | 0.11714    | 0.11714    |   0.0 |  0.39
Output  | 0.00015096 | 0.00015096 | 0.00015096 |   0.0 |  0.00
Modify  | 0.36267    | 0.36267    | 0.36267    |   0.0 |  1.19
Other   |            | 0.06434    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5121.00 ave        5121 max        5121 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:      311906.0 ave      311906 max      311906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311906
Ave neighs/atom = 155.95300
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 = 253.777358790423, Press = 7.21153888019034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -7151.9691   -7151.9691   -7216.5018   -7216.5018    249.74797    249.74797    23472.458    23472.458    966.89979    966.89979 
   15000   -7144.3246   -7144.3246    -7211.643    -7211.643    260.52925    260.52925    23488.517    23488.517    777.19068    777.19068 
Loop time of 30.3528 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.847 ns/day, 8.431 hours/ns, 32.946 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.806     | 29.806     | 29.806     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11884    | 0.11884    | 0.11884    |   0.0 |  0.39
Output  | 0.0002028  | 0.0002028  | 0.0002028  |   0.0 |  0.00
Modify  | 0.36359    | 0.36359    | 0.36359    |   0.0 |  1.20
Other   |            | 0.0638     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312196.0 ave      312196 max      312196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312196
Ave neighs/atom = 156.09800
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 = 253.82154249243, Press = 8.14582037981194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -7144.3246   -7144.3246    -7211.643    -7211.643    260.52925    260.52925    23488.517    23488.517    777.19068    777.19068 
   16000   -7151.0843   -7151.0843   -7215.3965   -7215.3965    248.89495    248.89495    23481.054    23481.054    719.81394    719.81394 
Loop time of 31.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.774 ns/day, 8.653 hours/ns, 32.103 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.587     | 30.587     | 30.587     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.39
Output  | 0.00015536 | 0.00015536 | 0.00015536 |   0.0 |  0.00
Modify  | 0.37678    | 0.37678    | 0.37678    |   0.0 |  1.21
Other   |            | 0.06519    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5169.00 ave        5169 max        5169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311664.0 ave      311664 max      311664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311664
Ave neighs/atom = 155.83200
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 = 253.944547484602, Press = 1.16376158331073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7151.0843   -7151.0843   -7215.3965   -7215.3965    248.89495    248.89495    23481.054    23481.054    719.81394    719.81394 
   17000   -7147.9002   -7147.9002   -7215.0243   -7215.0243    259.77752    259.77752    23463.544    23463.544    1921.9869    1921.9869 
Loop time of 31.9734 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.702 ns/day, 8.881 hours/ns, 31.276 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.401     | 31.401     | 31.401     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12312    | 0.12312    | 0.12312    |   0.0 |  0.39
Output  | 0.00015793 | 0.00015793 | 0.00015793 |   0.0 |  0.00
Modify  | 0.38248    | 0.38248    | 0.38248    |   0.0 |  1.20
Other   |            | 0.06619    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311960.0 ave      311960 max      311960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311960
Ave neighs/atom = 155.98000
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 = 253.971915471946, Press = 1.11891065814593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7147.9002   -7147.9002   -7215.0243   -7215.0243    259.77752    259.77752    23463.544    23463.544    1921.9869    1921.9869 
   18000   -7149.2798   -7149.2798   -7214.6008   -7214.6008    252.79896    252.79896    23475.516    23475.516    1673.4651    1673.4651 
Loop time of 30.7104 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.531 hours/ns, 32.562 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.158     | 30.158     | 30.158     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11927    | 0.11927    | 0.11927    |   0.0 |  0.39
Output  | 0.00019625 | 0.00019625 | 0.00019625 |   0.0 |  0.00
Modify  | 0.36792    | 0.36792    | 0.36792    |   0.0 |  1.20
Other   |            | 0.06486    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5133.00 ave        5133 max        5133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312094.0 ave      312094 max      312094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312094
Ave neighs/atom = 156.04700
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 = 253.966481085345, Press = 0.646577959101394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7149.2798   -7149.2798   -7214.6008   -7214.6008    252.79896    252.79896    23475.516    23475.516    1673.4651    1673.4651 
   19000   -7152.9471   -7152.9471   -7217.7884   -7217.7884    250.94258    250.94258    23492.736    23492.736   -422.99016   -422.99016 
Loop time of 30.1915 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.862 ns/day, 8.387 hours/ns, 33.122 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.645     | 29.645     | 29.645     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11839    | 0.11839    | 0.11839    |   0.0 |  0.39
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.36307    | 0.36307    | 0.36307    |   0.0 |  1.20
Other   |            | 0.06501    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311964.0 ave      311964 max      311964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311964
Ave neighs/atom = 155.98200
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 = 253.968918636817, Press = -3.86259383182894
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7152.9471   -7152.9471   -7217.7884   -7217.7884    250.94258    250.94258    23492.736    23492.736   -422.99016   -422.99016 
   20000   -7150.4328   -7150.4328   -7217.3175   -7217.3175    258.85069    258.85069    23493.795    23493.795   -331.78405   -331.78405 
Loop time of 30.5656 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.490 hours/ns, 32.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.014     | 30.014     | 30.014     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11878    | 0.11878    | 0.11878    |   0.0 |  0.39
Output  | 0.00015321 | 0.00015321 | 0.00015321 |   0.0 |  0.00
Modify  | 0.36852    | 0.36852    | 0.36852    |   0.0 |  1.21
Other   |            | 0.06404    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311866.0 ave      311866 max      311866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311866
Ave neighs/atom = 155.93300
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 = 253.919949085211, Press = -4.98337596889766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7150.4328   -7150.4328   -7217.3175   -7217.3175    258.85069    258.85069    23493.795    23493.795   -331.78405   -331.78405 
   21000   -7153.2346   -7153.2346   -7216.4571   -7216.4571    244.67761    244.67761    23518.595    23518.595   -2812.8977   -2812.8977 
Loop time of 30.7095 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.530 hours/ns, 32.563 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.158     | 30.158     | 30.158     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11901    | 0.11901    | 0.11901    |   0.0 |  0.39
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.36737    | 0.36737    | 0.36737    |   0.0 |  1.20
Other   |            | 0.06453    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311888.0 ave      311888 max      311888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311888
Ave neighs/atom = 155.94400
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 = 253.860257165745, Press = -1.35670810968222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7153.2346   -7153.2346   -7216.4571   -7216.4571    244.67761    244.67761    23518.595    23518.595   -2812.8977   -2812.8977 
   22000   -7150.3913   -7150.3913   -7215.2431   -7215.2431    250.98328    250.98328    23520.248    23520.248   -2632.4658   -2632.4658 
Loop time of 31.7338 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.815 hours/ns, 31.512 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.168     | 31.168     | 31.168     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.38
Output  | 0.00015772 | 0.00015772 | 0.00015772 |   0.0 |  0.00
Modify  | 0.37816    | 0.37816    | 0.37816    |   0.0 |  1.19
Other   |            | 0.06501    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311514.0 ave      311514 max      311514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311514
Ave neighs/atom = 155.75700
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 = 253.823820220531, Press = -1.00775007450607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7150.3913   -7150.3913   -7215.2431   -7215.2431    250.98328    250.98328    23520.248    23520.248   -2632.4658   -2632.4658 
   23000   -7153.8735   -7153.8735    -7218.172    -7218.172    248.84177    248.84177    23500.474    23500.474   -1537.8176   -1537.8176 
Loop time of 31.0389 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.622 hours/ns, 32.218 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.486     | 30.486     | 30.486     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11922    | 0.11922    | 0.11922    |   0.0 |  0.38
Output  | 0.00015232 | 0.00015232 | 0.00015232 |   0.0 |  0.00
Modify  | 0.36918    | 0.36918    | 0.36918    |   0.0 |  1.19
Other   |            | 0.06422    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 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:      311336.0 ave      311336 max      311336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311336
Ave neighs/atom = 155.66800
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 = 253.713821487388, Press = 0.806184274118755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7153.8735   -7153.8735    -7218.172    -7218.172    248.84177    248.84177    23500.474    23500.474   -1537.8176   -1537.8176 
   24000   -7149.5004   -7149.5004   -7216.0622   -7216.0622    257.60083    257.60083    23494.573    23494.573   -351.89951   -351.89951 
Loop time of 30.9235 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.794 ns/day, 8.590 hours/ns, 32.338 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.371     | 30.371     | 30.371     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11873    | 0.11873    | 0.11873    |   0.0 |  0.38
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.3686     | 0.3686     | 0.3686     |   0.0 |  1.19
Other   |            | 0.06472    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311804.0 ave      311804 max      311804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311804
Ave neighs/atom = 155.90200
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 = 253.620930522353, Press = 2.17937085160897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7149.5004   -7149.5004   -7216.0622   -7216.0622    257.60083    257.60083    23494.573    23494.573   -351.89951   -351.89951 
   25000   -7151.0533   -7151.0533   -7215.6587   -7215.6587    250.02985    250.02985    23481.695    23481.695    169.34508    169.34508 
Loop time of 30.6107 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.823 ns/day, 8.503 hours/ns, 32.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.058     | 30.058     | 30.058     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11937    | 0.11937    | 0.11937    |   0.0 |  0.39
Output  | 0.00015299 | 0.00015299 | 0.00015299 |   0.0 |  0.00
Modify  | 0.36852    | 0.36852    | 0.36852    |   0.0 |  1.20
Other   |            | 0.06458    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311778.0 ave      311778 max      311778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311778
Ave neighs/atom = 155.88900
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 = 253.55899419778, Press = 2.14988343645106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -7151.0533   -7151.0533   -7215.6587   -7215.6587    250.02985    250.02985    23481.695    23481.695    169.34508    169.34508 
   26000   -7148.3652   -7148.3652   -7214.6383   -7214.6383    256.48372    256.48372    23462.759    23462.759    1888.2518    1888.2518 
Loop time of 31.0621 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.782 ns/day, 8.628 hours/ns, 32.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    | 30.508     | 30.508     | 30.508     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11878    | 0.11878    | 0.11878    |   0.0 |  0.38
Output  | 0.00015286 | 0.00015286 | 0.00015286 |   0.0 |  0.00
Modify  | 0.37044    | 0.37044    | 0.37044    |   0.0 |  1.19
Other   |            | 0.06439    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311730.0 ave      311730 max      311730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311730
Ave neighs/atom = 155.86500
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 = 253.52849683904, Press = 0.329474846665208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7148.3652   -7148.3652   -7214.6383   -7214.6383    256.48372    256.48372    23462.759    23462.759    1888.2518    1888.2518 
   27000   -7151.1987   -7151.1987   -7215.9228   -7215.9228    250.48923    250.48923    23466.572    23466.572    1886.3317    1886.3317 
Loop time of 30.1933 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.862 ns/day, 8.387 hours/ns, 33.120 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.651     | 29.651     | 29.651     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11723    | 0.11723    | 0.11723    |   0.0 |  0.39
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.36036    | 0.36036    | 0.36036    |   0.0 |  1.19
Other   |            | 0.06424    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312206.0 ave      312206 max      312206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312206
Ave neighs/atom = 156.10300
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 = 253.495369021676, Press = 0.962135949306342
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7151.1987   -7151.1987   -7215.9228   -7215.9228    250.48923    250.48923    23466.572    23466.572    1886.3317    1886.3317 
   28000    -7151.548    -7151.548   -7215.7652   -7215.7652    248.52741    248.52741    23452.303    23452.303    2829.2492    2829.2492 
Loop time of 30.0379 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.876 ns/day, 8.344 hours/ns, 33.291 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.494     | 29.494     | 29.494     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11811    | 0.11811    | 0.11811    |   0.0 |  0.39
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.3613     | 0.3613     | 0.3613     |   0.0 |  1.20
Other   |            | 0.06417    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312296.0 ave      312296 max      312296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312296
Ave neighs/atom = 156.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 = 253.491784602712, Press = -2.13030217608958
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -7151.548    -7151.548   -7215.7652   -7215.7652    248.52741    248.52741    23452.303    23452.303    2829.2492    2829.2492 
   29000   -7146.0791   -7146.0791   -7213.3536   -7213.3536    260.35906    260.35906    23478.022    23478.022    1345.3457    1345.3457 
Loop time of 29.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.885 ns/day, 8.320 hours/ns, 33.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.41      | 29.41      | 29.41      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11786    | 0.11786    | 0.11786    |   0.0 |  0.39
Output  | 0.00015264 | 0.00015264 | 0.00015264 |   0.0 |  0.00
Modify  | 0.36018    | 0.36018    | 0.36018    |   0.0 |  1.20
Other   |            | 0.06473    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312422.0 ave      312422 max      312422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312422
Ave neighs/atom = 156.21100
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 = 253.502032120135, Press = -4.2637035711204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -7146.0791   -7146.0791   -7213.3536   -7213.3536    260.35906    260.35906    23478.022    23478.022    1345.3457    1345.3457 
   30000   -7152.0026   -7152.0026   -7217.0581   -7217.0581     251.7717     251.7717    23472.747    23472.747    1037.3643    1037.3643 
Loop time of 30.6113 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.822 ns/day, 8.503 hours/ns, 32.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.06      | 30.06      | 30.06      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11891    | 0.11891    | 0.11891    |   0.0 |  0.39
Output  | 0.00019738 | 0.00019738 | 0.00019738 |   0.0 |  0.00
Modify  | 0.36784    | 0.36784    | 0.36784    |   0.0 |  1.20
Other   |            | 0.06426    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 155.99100
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 = 253.570745716334, Press = -1.20740332459763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7152.0026   -7152.0026   -7217.0581   -7217.0581     251.7717     251.7717    23472.747    23472.747    1037.3643    1037.3643 
   31000   -7148.4028   -7148.4028   -7213.7662   -7213.7662    252.96343    252.96343    23514.325    23514.325   -1649.4595   -1649.4595 
Loop time of 30.4409 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.838 ns/day, 8.456 hours/ns, 32.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.895     | 29.895     | 29.895     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11757    | 0.11757    | 0.11757    |   0.0 |  0.39
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.36344    | 0.36344    | 0.36344    |   0.0 |  1.19
Other   |            | 0.06442    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5144.00 ave        5144 max        5144 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:      312124.0 ave      312124 max      312124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312124
Ave neighs/atom = 156.06200
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 = 253.591559371817, Press = -0.566625937768728
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7148.4028   -7148.4028   -7213.7662   -7213.7662    252.96343    252.96343    23514.325    23514.325   -1649.4595   -1649.4595 
   32000    -7152.413    -7152.413    -7215.271    -7215.271     243.2666     243.2666    23501.041    23501.041   -1232.1573   -1232.1573 
Loop time of 31.4515 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.737 hours/ns, 31.795 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.891     | 30.891     | 30.891     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12062    | 0.12062    | 0.12062    |   0.0 |  0.38
Output  | 0.00015846 | 0.00015846 | 0.00015846 |   0.0 |  0.00
Modify  | 0.37547    | 0.37547    | 0.37547    |   0.0 |  1.19
Other   |            | 0.06471    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311596.0 ave      311596 max      311596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311596
Ave neighs/atom = 155.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 = 253.573524315445, Press = -0.858879715422628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -7152.413    -7152.413    -7215.271    -7215.271     243.2666     243.2666    23501.041    23501.041   -1232.1573   -1232.1573 
   33000    -7149.097    -7149.097   -7216.2615   -7216.2615    259.93326    259.93326    23512.539    23512.539   -2026.8385   -2026.8385 
Loop time of 30.1616 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.865 ns/day, 8.378 hours/ns, 33.155 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.606     | 29.606     | 29.606     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1306     | 0.1306     | 0.1306     |   0.0 |  0.43
Output  | 0.0002009  | 0.0002009  | 0.0002009  |   0.0 |  0.00
Modify  | 0.36014    | 0.36014    | 0.36014    |   0.0 |  1.19
Other   |            | 0.06429    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5158.00 ave        5158 max        5158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311820.0 ave      311820 max      311820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311820
Ave neighs/atom = 155.91000
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 = 253.539849892123, Press = -1.06838268937984
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -7149.097    -7149.097   -7216.2615   -7216.2615    259.93326    259.93326    23512.539    23512.539   -2026.8385   -2026.8385 
   34000   -7149.6103   -7149.6103   -7215.7761   -7215.7761    256.06848    256.06848     23519.83     23519.83   -2596.1562   -2596.1562 
Loop time of 31.9667 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.880 hours/ns, 31.283 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.402     | 31.402     | 31.402     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.122      | 0.122      | 0.122      |   0.0 |  0.38
Output  | 0.00015012 | 0.00015012 | 0.00015012 |   0.0 |  0.00
Modify  | 0.37684    | 0.37684    | 0.37684    |   0.0 |  1.18
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:        5162.00 ave        5162 max        5162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311562.0 ave      311562 max      311562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311562
Ave neighs/atom = 155.78100
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 = 253.547053111687, Press = 1.28686096740575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7149.6103   -7149.6103   -7215.7761   -7215.7761    256.06848    256.06848     23519.83     23519.83   -2596.1562   -2596.1562 
   35000    -7148.737    -7148.737   -7214.4618   -7214.4618     254.3615     254.3615    23502.246    23502.246   -925.16626   -925.16626 
Loop time of 31.0293 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.619 hours/ns, 32.228 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.471     | 30.471     | 30.471     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12       | 0.12       | 0.12       |   0.0 |  0.39
Output  | 0.00015185 | 0.00015185 | 0.00015185 |   0.0 |  0.00
Modify  | 0.37362    | 0.37362    | 0.37362    |   0.0 |  1.20
Other   |            | 0.06451    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5149.00 ave        5149 max        5149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311594.0 ave      311594 max      311594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311594
Ave neighs/atom = 155.79700
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 = 253.580442790821, Press = 2.37965454614983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -7148.737    -7148.737   -7214.4618   -7214.4618     254.3615     254.3615    23502.246    23502.246   -925.16626   -925.16626 
   36000   -7153.5028   -7153.5028   -7218.1359   -7218.1359    250.13676    250.13676    23484.511    23484.511   -94.264166   -94.264166 
Loop time of 30.5577 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.488 hours/ns, 32.725 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.009     | 30.009     | 30.009     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11844    | 0.11844    | 0.11844    |   0.0 |  0.39
Output  | 0.00019221 | 0.00019221 | 0.00019221 |   0.0 |  0.00
Modify  | 0.36585    | 0.36585    | 0.36585    |   0.0 |  1.20
Other   |            | 0.06417    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311784.0 ave      311784 max      311784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311784
Ave neighs/atom = 155.89200
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 = 253.524877820815, Press = -0.0312973901054449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7153.5028   -7153.5028   -7218.1359   -7218.1359    250.13676    250.13676    23484.511    23484.511   -94.264166   -94.264166 
   37000   -7149.7328   -7149.7328   -7215.8433   -7215.8433    255.85447    255.85447    23470.272    23470.272    856.31697    856.31697 
Loop time of 30.6698 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.519 hours/ns, 32.605 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.12      | 30.12      | 30.12      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11863    | 0.11863    | 0.11863    |   0.0 |  0.39
Output  | 0.00015573 | 0.00015573 | 0.00015573 |   0.0 |  0.00
Modify  | 0.36624    | 0.36624    | 0.36624    |   0.0 |  1.19
Other   |            | 0.06476    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311956.0 ave      311956 max      311956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311956
Ave neighs/atom = 155.97800
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 = 253.476620607125, Press = 0.169631785222229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7149.7328   -7149.7328   -7215.8433   -7215.8433    255.85447    255.85447    23470.272    23470.272    856.31697    856.31697 
   38000   -7147.2228   -7147.2228   -7216.6768   -7216.6768    268.79391    268.79391    23480.278    23480.278    1198.8925    1198.8925 
Loop time of 30.8101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.804 ns/day, 8.558 hours/ns, 32.457 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.257     | 30.257     | 30.257     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11954    | 0.11954    | 0.11954    |   0.0 |  0.39
Output  | 0.00015436 | 0.00015436 | 0.00015436 |   0.0 |  0.00
Modify  | 0.36882    | 0.36882    | 0.36882    |   0.0 |  1.20
Other   |            | 0.06496    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311988.0 ave      311988 max      311988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311988
Ave neighs/atom = 155.99400
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 = 253.477215539842, Press = -0.579388808744284
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7147.2228   -7147.2228   -7216.6768   -7216.6768    268.79391    268.79391    23480.278    23480.278    1198.8925    1198.8925 
   39000   -7151.9545   -7151.9545   -7218.0396   -7218.0396    255.75629    255.75629    23450.368    23450.368    2617.6351    2617.6351 
Loop time of 31.4176 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.750 ns/day, 8.727 hours/ns, 31.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.858     | 30.858     | 30.858     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11933    | 0.11933    | 0.11933    |   0.0 |  0.38
Output  | 0.00019708 | 0.00019708 | 0.00019708 |   0.0 |  0.00
Modify  | 0.37571    | 0.37571    | 0.37571    |   0.0 |  1.20
Other   |            | 0.06472    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 155.85100
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 = 253.5025896483, Press = -0.321167764192515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7151.9545   -7151.9545   -7218.0396   -7218.0396    255.75629    255.75629    23450.368    23450.368    2617.6351    2617.6351 
   40000   -7148.8706   -7148.8706   -7214.1619   -7214.1619    252.68415    252.68415    23476.125    23476.125    936.04154    936.04154 
Loop time of 30.4143 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.841 ns/day, 8.448 hours/ns, 32.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.868     | 29.868     | 29.868     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11891    | 0.11891    | 0.11891    |   0.0 |  0.39
Output  | 0.00015751 | 0.00015751 | 0.00015751 |   0.0 |  0.00
Modify  | 0.36222    | 0.36222    | 0.36222    |   0.0 |  1.19
Other   |            | 0.06451    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312132.0 ave      312132 max      312132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312132
Ave neighs/atom = 156.06600
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 = 253.520512263253, Press = -2.00770013872759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -7148.8706   -7148.8706   -7214.1619   -7214.1619    252.68415    252.68415    23476.125    23476.125    936.04154    936.04154 
   41000    -7151.465    -7151.465   -7216.7415   -7216.7415    252.62704    252.62704    23487.872    23487.872    173.17418    173.17418 
Loop time of 30.6369 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.820 ns/day, 8.510 hours/ns, 32.640 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.087     | 30.087     | 30.087     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1197     | 0.1197     | 0.1197     |   0.0 |  0.39
Output  | 0.000153   | 0.000153   | 0.000153   |   0.0 |  0.00
Modify  | 0.36528    | 0.36528    | 0.36528    |   0.0 |  1.19
Other   |            | 0.06435    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312176.0 ave      312176 max      312176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312176
Ave neighs/atom = 156.08800
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 = 253.493453502184, Press = -1.09980567442036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -7151.465    -7151.465   -7216.7415   -7216.7415    252.62704    252.62704    23487.872    23487.872    173.17418    173.17418 
   42000   -7151.7178   -7151.7178    -7215.702    -7215.702    247.62532    247.62532    23501.861    23501.861   -1114.7112   -1114.7112 
Loop time of 30.9383 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.793 ns/day, 8.594 hours/ns, 32.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.384     | 30.384     | 30.384     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11993    | 0.11993    | 0.11993    |   0.0 |  0.39
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.36963    | 0.36963    | 0.36963    |   0.0 |  1.19
Other   |            | 0.06444    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312086.0 ave      312086 max      312086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312086
Ave neighs/atom = 156.04300
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 = 253.492066501428, Press = -1.02556804249409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7151.7178   -7151.7178    -7215.702    -7215.702    247.62532    247.62532    23501.861    23501.861   -1114.7112   -1114.7112 
   43000   -7148.8094   -7148.8094     -7214.67     -7214.67    254.88753    254.88753    23495.196    23495.196   -323.69326   -323.69326 
Loop time of 30.4394 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.838 ns/day, 8.455 hours/ns, 32.852 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.886     | 29.886     | 29.886     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11969    | 0.11969    | 0.11969    |   0.0 |  0.39
Output  | 0.00014918 | 0.00014918 | 0.00014918 |   0.0 |  0.00
Modify  | 0.3676     | 0.3676     | 0.3676     |   0.0 |  1.21
Other   |            | 0.06567    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5179.00 ave        5179 max        5179 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:      311798.0 ave      311798 max      311798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311798
Ave neighs/atom = 155.89900
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 = 253.48783376028, Press = -0.788707672768163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -7148.8094   -7148.8094     -7214.67     -7214.67    254.88753    254.88753    23495.196    23495.196   -323.69326   -323.69326 
   44000   -7150.8355   -7150.8355   -7215.8986   -7215.8986    251.80101    251.80101    23514.193    23514.193   -2403.7228   -2403.7228 
Loop time of 30.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.809 ns/day, 8.543 hours/ns, 32.514 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.202     | 30.202     | 30.202     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12027    | 0.12027    | 0.12027    |   0.0 |  0.39
Output  | 0.00015043 | 0.00015043 | 0.00015043 |   0.0 |  0.00
Modify  | 0.3688     | 0.3688     | 0.3688     |   0.0 |  1.20
Other   |            | 0.06435    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311948.0 ave      311948 max      311948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311948
Ave neighs/atom = 155.97400
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 = 253.433989082144, Press = 0.404887682583396
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7150.8355   -7150.8355   -7215.8986   -7215.8986    251.80101    251.80101    23514.193    23514.193   -2403.7228   -2403.7228 
   45000   -7150.5912   -7150.5912   -7216.8505   -7216.8505    256.43027    256.43027    23529.132    23529.132   -3212.9934   -3212.9934 
Loop time of 31.2965 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.693 hours/ns, 31.952 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.733     | 30.733     | 30.733     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.39
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.37661    | 0.37661    | 0.37661    |   0.0 |  1.20
Other   |            | 0.0652     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311590.0 ave      311590 max      311590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311590
Ave neighs/atom = 155.79500
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 = 253.435432245528, Press = 1.02213284979126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -7150.5912   -7150.5912   -7216.8505   -7216.8505    256.43027    256.43027    23529.132    23529.132   -3212.9934   -3212.9934 
   46000   -7148.6365   -7148.6365   -7214.0954   -7214.0954    253.33287    253.33287    23510.075    23510.075   -1175.3988   -1175.3988 
Loop time of 31.3641 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.884 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.798     | 30.798     | 30.798     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.39
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.37871    | 0.37871    | 0.37871    |   0.0 |  1.21
Other   |            | 0.06542    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5132.00 ave        5132 max        5132 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:      311460.0 ave      311460 max      311460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311460
Ave neighs/atom = 155.73000
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 = 253.427915394963, Press = 0.919734931228479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7148.6365   -7148.6365   -7214.0954   -7214.0954    253.33287    253.33287    23510.075    23510.075   -1175.3988   -1175.3988 
   47000   -7150.6471   -7150.6471   -7216.9095   -7216.9095    256.44248    256.44248    23474.284    23474.284    218.19831    218.19831 
Loop time of 31.4754 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.743 hours/ns, 31.771 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.911     | 30.911     | 30.911     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.38
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  1.20
Other   |            | 0.06524    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311516.0 ave      311516 max      311516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311516
Ave neighs/atom = 155.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 = 253.428919498352, Press = 0.670695111238863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -7150.6471   -7150.6471   -7216.9095   -7216.9095    256.44248    256.44248    23474.284    23474.284    218.19831    218.19831 
   48000   -7152.7719   -7152.7719   -7217.8501   -7217.8501    251.85942    251.85942    23464.003    23464.003    2020.5255    2020.5255 
Loop time of 30.328 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.849 ns/day, 8.424 hours/ns, 32.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.779     | 29.779     | 29.779     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11839    | 0.11839    | 0.11839    |   0.0 |  0.39
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.3656     | 0.3656     | 0.3656     |   0.0 |  1.21
Other   |            | 0.06469    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312062.0 ave      312062 max      312062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312062
Ave neighs/atom = 156.03100
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 = 253.41221694167, Press = 0.276425522203268
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -7152.7719   -7152.7719   -7217.8501   -7217.8501    251.85942    251.85942    23464.003    23464.003    2020.5255    2020.5255 
   49000   -7152.1138   -7152.1138   -7215.8127   -7215.8127    246.52124    246.52124    23462.332    23462.332    2157.2596    2157.2596 
Loop time of 31.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.622 hours/ns, 32.217 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.482     | 30.482     | 30.482     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11997    | 0.11997    | 0.11997    |   0.0 |  0.39
Output  | 0.00020496 | 0.00020496 | 0.00020496 |   0.0 |  0.00
Modify  | 0.37231    | 0.37231    | 0.37231    |   0.0 |  1.20
Other   |            | 0.06502    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5152.00 ave        5152 max        5152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312194.0 ave      312194 max      312194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312194
Ave neighs/atom = 156.09700
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 = 253.413557803728, Press = -0.0123263023121886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7152.1138   -7152.1138   -7215.8127   -7215.8127    246.52124    246.52124    23462.332    23462.332    2157.2596    2157.2596 
   50000   -7145.6283   -7145.6283   -7214.0652   -7214.0652    264.85801    264.85801     23473.37     23473.37    1374.1967    1374.1967 
Loop time of 30.7412 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.811 ns/day, 8.539 hours/ns, 32.530 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.189     | 30.189     | 30.189     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11932    | 0.11932    | 0.11932    |   0.0 |  0.39
Output  | 0.00015388 | 0.00015388 | 0.00015388 |   0.0 |  0.00
Modify  | 0.36729    | 0.36729    | 0.36729    |   0.0 |  1.19
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 156.02600
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 = 253.42044952447, Press = 0.179914235058182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7145.6283   -7145.6283   -7214.0652   -7214.0652    264.85801    264.85801     23473.37     23473.37    1374.1967    1374.1967 
   51000   -7152.3008   -7152.3008   -7217.6674   -7217.6674     252.9755     252.9755    23450.295    23450.295    2733.5378    2733.5378 
Loop time of 30.7471 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.810 ns/day, 8.541 hours/ns, 32.523 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.192     | 30.192     | 30.192     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11905    | 0.11905    | 0.11905    |   0.0 |  0.39
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.3707     | 0.3707     | 0.3707     |   0.0 |  1.21
Other   |            | 0.06481    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5158.00 ave        5158 max        5158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312104.0 ave      312104 max      312104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312104
Ave neighs/atom = 156.05200
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 = 253.449111554522, Press = -1.09270789901812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -7152.3008   -7152.3008   -7217.6674   -7217.6674     252.9755     252.9755    23450.295    23450.295    2733.5378    2733.5378 
   52000   -7150.0923   -7150.0923   -7216.7878   -7216.7878    258.11857    258.11857    23476.048    23476.048    980.40439    980.40439 
Loop time of 30.4798 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.835 ns/day, 8.467 hours/ns, 32.809 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.93      | 29.93      | 29.93      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11809    | 0.11809    | 0.11809    |   0.0 |  0.39
Output  | 0.00015365 | 0.00015365 | 0.00015365 |   0.0 |  0.00
Modify  | 0.36771    | 0.36771    | 0.36771    |   0.0 |  1.21
Other   |            | 0.06393    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312318.0 ave      312318 max      312318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312318
Ave neighs/atom = 156.15900
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 = 253.448173375554, Press = -1.51120373575124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7150.0923   -7150.0923   -7216.7878   -7216.7878    258.11857    258.11857    23476.048    23476.048    980.40439    980.40439 
   53000   -7150.9694   -7150.9694   -7216.3656   -7216.3656    253.09009    253.09009    23492.784    23492.784   -700.24282   -700.24282 
Loop time of 30.1805 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.863 ns/day, 8.383 hours/ns, 33.134 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.638     | 29.638     | 29.638     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11847    | 0.11847    | 0.11847    |   0.0 |  0.39
Output  | 0.00015277 | 0.00015277 | 0.00015277 |   0.0 |  0.00
Modify  | 0.36051    | 0.36051    | 0.36051    |   0.0 |  1.19
Other   |            | 0.06385    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5184.00 ave        5184 max        5184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 156.02200
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 = 253.434136220383, Press = -1.5196890156583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7150.9694   -7150.9694   -7216.3656   -7216.3656    253.09009    253.09009    23492.784    23492.784   -700.24282   -700.24282 
   54000   -7154.2747   -7154.2747   -7218.4808   -7218.4808    248.48447    248.48447    23494.401    23494.401   -1103.3957   -1103.3957 
Loop time of 30.6348 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.820 ns/day, 8.510 hours/ns, 32.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.087     | 30.087     | 30.087     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11826    | 0.11826    | 0.11826    |   0.0 |  0.39
Output  | 0.00015579 | 0.00015579 | 0.00015579 |   0.0 |  0.00
Modify  | 0.36462    | 0.36462    | 0.36462    |   0.0 |  1.19
Other   |            | 0.0643     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311636.0 ave      311636 max      311636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311636
Ave neighs/atom = 155.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 = 253.430414254217, Press = -0.274556652531327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7154.2747   -7154.2747   -7218.4808   -7218.4808    248.48447    248.48447    23494.401    23494.401   -1103.3957   -1103.3957 
   55000   -7149.6587   -7149.6587   -7215.2351   -7215.2351    253.78752    253.78752    23514.211    23514.211    -1890.653    -1890.653 
Loop time of 30.2931 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.852 ns/day, 8.415 hours/ns, 33.011 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.75      | 29.75      | 29.75      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1166     | 0.1166     | 0.1166     |   0.0 |  0.38
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.362      | 0.362      | 0.362      |   0.0 |  1.19
Other   |            | 0.06479    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311966.0 ave      311966 max      311966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311966
Ave neighs/atom = 155.98300
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 = 253.38959569825, Press = -0.410878571244813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7149.6587   -7149.6587   -7215.2351   -7215.2351    253.78752    253.78752    23514.211    23514.211    -1890.653    -1890.653 
   56000   -7149.3136   -7149.3136   -7214.2055   -7214.2055    251.13867    251.13867    23496.231    23496.231   -195.03708   -195.03708 
Loop time of 31.1613 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.773 ns/day, 8.656 hours/ns, 32.091 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.6       | 30.6       | 30.6       |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12061    | 0.12061    | 0.12061    |   0.0 |  0.39
Output  | 0.00016709 | 0.00016709 | 0.00016709 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  1.21
Other   |            | 0.0649     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5163.00 ave        5163 max        5163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311680.0 ave      311680 max      311680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311680
Ave neighs/atom = 155.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 = 253.358510752438, Press = -0.00855416619019929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -7149.3136   -7149.3136   -7214.2055   -7214.2055    251.13867    251.13867    23496.231    23496.231   -195.03708   -195.03708 
   57000   -7153.3859   -7153.3859   -7216.7619   -7216.7619    245.27175    245.27175    23469.747    23469.747    1085.0527    1085.0527 
Loop time of 30.2661 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.855 ns/day, 8.407 hours/ns, 33.040 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.717     | 29.717     | 29.717     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.39
Output  | 0.00015301 | 0.00015301 | 0.00015301 |   0.0 |  0.00
Modify  | 0.36578    | 0.36578    | 0.36578    |   0.0 |  1.21
Other   |            | 0.06476    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311782.0 ave      311782 max      311782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311782
Ave neighs/atom = 155.89100
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 = 253.350368659266, Press = 1.05139861133561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -7153.3859   -7153.3859   -7216.7619   -7216.7619    245.27175    245.27175    23469.747    23469.747    1085.0527    1085.0527 
   58000   -7149.5663   -7149.5663   -7214.2794   -7214.2794    250.44667    250.44667    23495.182    23495.182    27.046356    27.046356 
Loop time of 30.1544 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.865 ns/day, 8.376 hours/ns, 33.163 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.606     | 29.606     | 29.606     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11921    | 0.11921    | 0.11921    |   0.0 |  0.40
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.36419    | 0.36419    | 0.36419    |   0.0 |  1.21
Other   |            | 0.06466    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 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:      312298.0 ave      312298 max      312298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312298
Ave neighs/atom = 156.14900
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
23488.3040608198

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0