# 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 4.049985826015473*${_u_distance}
variable latticeconst_converted equal 4.049985826015473*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04998582601547
Lattice spacing in x,y,z = 4.0499858 4.0499858 4.0499858
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 (40.499858 40.499858 40.499858)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.499858 40.499858 40.499858)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_SunRamachandranWick_2018_TiAl__MO_022920256108_001
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_022920256108_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13261.013   -13261.013   -13412.545   -13412.545       293.15       293.15    66429.428    66429.428    2436.4767    2436.4767 
    1000   -13095.216   -13095.216   -13248.569   -13248.569    296.67156    296.67156    67552.938    67552.938    -1078.453    -1078.453 
Loop time of 224.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.444 hours/ns, 4.448 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    | 223.88     | 223.88     | 223.88     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11333    | 0.11333    | 0.11333    |   0.0 |  0.05
Output  | 0.00025942 | 0.00025942 | 0.00025942 |   0.0 |  0.00
Modify  | 0.70329    | 0.70329    | 0.70329    |   0.0 |  0.31
Other   |            | 0.09551    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3813.00 ave        3813 max        3813 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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13095.216   -13095.216   -13248.569   -13248.569    296.67156    296.67156    67552.938    67552.938    -1078.453    -1078.453 
    2000   -13108.961   -13108.961   -13257.593   -13257.593    287.53946    287.53946    67322.544    67322.544    591.30056    591.30056 
Loop time of 234.673 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.187 hours/ns, 4.261 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    | 233.78     | 233.78     | 233.78     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11439    | 0.11439    | 0.11439    |   0.0 |  0.05
Output  | 0.00025457 | 0.00025457 | 0.00025457 |   0.0 |  0.00
Modify  | 0.68749    | 0.68749    | 0.68749    |   0.0 |  0.29
Other   |            | 0.09452    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4063.00 ave        4063 max        4063 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:      214724.0 ave      214724 max      214724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214724
Ave neighs/atom = 53.681000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13108.961   -13108.961   -13257.593   -13257.593    287.53946    287.53946    67322.544    67322.544    591.30056    591.30056 
    3000   -13103.402   -13103.402    -13252.87    -13252.87     289.1542     289.1542     67436.64     67436.64   -264.42645   -264.42645 
Loop time of 231.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.260 hours/ns, 4.323 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    | 230.46     | 230.46     | 230.46     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11107    | 0.11107    | 0.11107    |   0.0 |  0.05
Output  | 0.00024708 | 0.00024708 | 0.00024708 |   0.0 |  0.00
Modify  | 0.66734    | 0.66734    | 0.66734    |   0.0 |  0.29
Other   |            | 0.09346    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4047.00 ave        4047 max        4047 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:      215072.0 ave      215072 max      215072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215072
Ave neighs/atom = 53.768000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13103.402   -13103.402    -13252.87    -13252.87     289.1542     289.1542     67436.64     67436.64   -264.42645   -264.42645 
    4000   -13104.056   -13104.056   -13256.968   -13256.968    295.82008    295.82008    67371.689    67371.689    241.12322    241.12322 
Loop time of 233.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.936 hours/ns, 4.278 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    | 232.88     | 232.88     | 232.88     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11415    | 0.11415    | 0.11415    |   0.0 |  0.05
Output  | 0.0002112  | 0.0002112  | 0.0002112  |   0.0 |  0.00
Modify  | 0.68251    | 0.68251    | 0.68251    |   0.0 |  0.29
Other   |            | 0.09452    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4056.00 ave        4056 max        4056 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:      215004.0 ave      215004 max      215004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215004
Ave neighs/atom = 53.751000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13104.056   -13104.056   -13256.968   -13256.968    295.82008    295.82008    67371.689    67371.689    241.12322    241.12322 
    5000   -13106.427   -13106.427   -13252.456   -13252.456    282.50232    282.50232    67431.481    67431.481   -244.68125   -244.68125 
Loop time of 232.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.545 hours/ns, 4.304 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    | 231.48     | 231.48     | 231.48     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11231    | 0.11231    | 0.11231    |   0.0 |  0.05
Output  | 0.00017824 | 0.00017824 | 0.00017824 |   0.0 |  0.00
Modify  | 0.67885    | 0.67885    | 0.67885    |   0.0 |  0.29
Other   |            | 0.09428    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4023.00 ave        4023 max        4023 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:      214968.0 ave      214968 max      214968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214968
Ave neighs/atom = 53.742000
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 = 290.861441872781, Press = 260.084774012886
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13106.427   -13106.427   -13252.456   -13252.456    282.50232    282.50232    67431.481    67431.481   -244.68125   -244.68125 
    6000   -13103.668   -13103.668   -13257.012   -13257.012    296.65497    296.65497    67345.396    67345.396    498.46889    498.46889 
Loop time of 233.987 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.996 hours/ns, 4.274 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    | 233.07     | 233.07     | 233.07     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11447    | 0.11447    | 0.11447    |   0.0 |  0.05
Output  | 0.00017678 | 0.00017678 | 0.00017678 |   0.0 |  0.00
Modify  | 0.7082     | 0.7082     | 0.7082     |   0.0 |  0.30
Other   |            | 0.09467    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4080.00 ave        4080 max        4080 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:      214852.0 ave      214852 max      214852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214852
Ave neighs/atom = 53.713000
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 = 292.712586280255, Press = -23.1513963255357
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13103.668   -13103.668   -13257.012   -13257.012    296.65497    296.65497    67345.396    67345.396    498.46889    498.46889 
    7000   -13105.931   -13105.931   -13258.278   -13258.278    294.72458    294.72458    67432.202    67432.202   -390.85528   -390.85528 
Loop time of 228.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.576 hours/ns, 4.369 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    | 227.99     | 227.99     | 227.99     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11126    | 0.11126    | 0.11126    |   0.0 |  0.05
Output  | 0.00017606 | 0.00017606 | 0.00017606 |   0.0 |  0.00
Modify  | 0.6843     | 0.6843     | 0.6843     |   0.0 |  0.30
Other   |            | 0.09299    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4077.00 ave        4077 max        4077 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:      215074.0 ave      215074 max      215074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215074
Ave neighs/atom = 53.768500
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 = 293.17388499684, Press = 26.1996598797407
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13105.931   -13105.931   -13258.278   -13258.278    294.72458    294.72458    67432.202    67432.202   -390.85528   -390.85528 
    8000   -13102.904   -13102.904    -13255.54    -13255.54    295.28344    295.28344    67408.305    67408.305   -46.477597   -46.477597 
Loop time of 236.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.698 hours/ns, 4.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    | 235.59     | 235.59     | 235.59     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11343    | 0.11343    | 0.11343    |   0.0 |  0.05
Output  | 0.00017826 | 0.00017826 | 0.00017826 |   0.0 |  0.00
Modify  | 0.71563    | 0.71563    | 0.71563    |   0.0 |  0.30
Other   |            | 0.09558    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4012.00 ave        4012 max        4012 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:      214918.0 ave      214918 max      214918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214918
Ave neighs/atom = 53.729500
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 = 292.788007047134, Press = -4.46663701055173
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13102.904   -13102.904    -13255.54    -13255.54    295.28344    295.28344    67408.305    67408.305   -46.477597   -46.477597 
    9000   -13110.242   -13110.242   -13258.067   -13258.067    285.97591    285.97591    67360.622    67360.622    196.37306    196.37306 
Loop time of 230.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.959 hours/ns, 4.343 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    | 229.36     | 229.36     | 229.36     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11283    | 0.11283    | 0.11283    |   0.0 |  0.05
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.68727    | 0.68727    | 0.68727    |   0.0 |  0.30
Other   |            | 0.09339    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4064.00 ave        4064 max        4064 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:      214988.0 ave      214988 max      214988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214988
Ave neighs/atom = 53.747000
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 = 292.525090138587, Press = 7.36183792899063
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13110.242   -13110.242   -13258.067   -13258.067    285.97591    285.97591    67360.622    67360.622    196.37306    196.37306 
   10000   -13100.664   -13100.664   -13255.401   -13255.401     299.3502     299.3502    67443.355    67443.355   -347.35263   -347.35263 
Loop time of 233.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.976 hours/ns, 4.275 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    | 233        | 233        | 233        |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11439    | 0.11439    | 0.11439    |   0.0 |  0.05
Output  | 0.00017822 | 0.00017822 | 0.00017822 |   0.0 |  0.00
Modify  | 0.7061     | 0.7061     | 0.7061     |   0.0 |  0.30
Other   |            | 0.09483    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4063.00 ave        4063 max        4063 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:      214978.0 ave      214978 max      214978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214978
Ave neighs/atom = 53.744500
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 = 292.5880522717, Press = -0.558832117499386
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13100.664   -13100.664   -13255.401   -13255.401     299.3502     299.3502    67443.355    67443.355   -347.35263   -347.35263 
   11000   -13104.981   -13104.981   -13255.048   -13255.048    290.31395    290.31395    67362.582    67362.582    392.42464    392.42464 
Loop time of 231.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.424 hours/ns, 4.312 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    | 231.02     | 231.02     | 231.02     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11331    | 0.11331    | 0.11331    |   0.0 |  0.05
Output  | 0.00017926 | 0.00017926 | 0.00017926 |   0.0 |  0.00
Modify  | 0.69579    | 0.69579    | 0.69579    |   0.0 |  0.30
Other   |            | 0.09362    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4091.00 ave        4091 max        4091 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:      214932.0 ave      214932 max      214932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214932
Ave neighs/atom = 53.733000
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 = 292.674237068087, Press = 4.74373257329893
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13104.981   -13104.981   -13255.048   -13255.048    290.31395    290.31395    67362.582    67362.582    392.42464    392.42464 
   12000    -13101.95    -13101.95   -13252.996   -13252.996    292.20994    292.20994    67464.515    67464.515   -486.65885   -486.65885 
Loop time of 234.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.184 hours/ns, 4.261 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    | 233.74     | 233.74     | 233.74     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11464    | 0.11464    | 0.11464    |   0.0 |  0.05
Output  | 0.00018049 | 0.00018049 | 0.00018049 |   0.0 |  0.00
Modify  | 0.70798    | 0.70798    | 0.70798    |   0.0 |  0.30
Other   |            | 0.09477    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4063.00 ave        4063 max        4063 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:      215036.0 ave      215036 max      215036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215036
Ave neighs/atom = 53.759000
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 = 292.74978427424, Press = -1.81306830834063
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -13101.95    -13101.95   -13252.996   -13252.996    292.20994    292.20994    67464.515    67464.515   -486.65885   -486.65885 
   13000   -13103.907   -13103.907    -13254.46    -13254.46    291.25349    291.25349    67324.651    67324.651     781.3183     781.3183 
Loop time of 231.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.268 hours/ns, 4.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    | 230.46     | 230.46     | 230.46     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11188    | 0.11188    | 0.11188    |   0.0 |  0.05
Output  | 0.00018081 | 0.00018081 | 0.00018081 |   0.0 |  0.00
Modify  | 0.69458    | 0.69458    | 0.69458    |   0.0 |  0.30
Other   |            | 0.09379    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4016.00 ave        4016 max        4016 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:      214868.0 ave      214868 max      214868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214868
Ave neighs/atom = 53.717000
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 = 292.796814483083, Press = 3.75867784179313
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13103.907   -13103.907    -13254.46    -13254.46    291.25349    291.25349    67324.651    67324.651     781.3183     781.3183 
   14000   -13103.002   -13103.002   -13253.306   -13253.306    290.77245    290.77245    67485.659    67485.659   -728.75158   -728.75158 
Loop time of 235.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.389 hours/ns, 4.248 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    | 234.47     | 234.47     | 234.47     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11587    | 0.11587    | 0.11587    |   0.0 |  0.05
Output  | 0.00017901 | 0.00017901 | 0.00017901 |   0.0 |  0.00
Modify  | 0.71549    | 0.71549    | 0.71549    |   0.0 |  0.30
Other   |            | 0.09555    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4078.00 ave        4078 max        4078 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:      215014.0 ave      215014 max      215014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215014
Ave neighs/atom = 53.753500
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 = 293.122260638092, Press = -1.06694817937783
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13103.002   -13103.002   -13253.306   -13253.306    290.77245    290.77245    67485.659    67485.659   -728.75158   -728.75158 
   15000   -13104.118   -13104.118   -13256.413   -13256.413    294.62528    294.62528    67258.295    67258.295    1342.4388    1342.4388 
Loop time of 235.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.333 hours/ns, 4.252 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    | 234.27     | 234.27     | 234.27     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11412    | 0.11412    | 0.11412    |   0.0 |  0.05
Output  | 0.00017927 | 0.00017927 | 0.00017927 |   0.0 |  0.00
Modify  | 0.71748    | 0.71748    | 0.71748    |   0.0 |  0.31
Other   |            | 0.09578    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4025.00 ave        4025 max        4025 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:      214906.0 ave      214906 max      214906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214906
Ave neighs/atom = 53.726500
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 = 293.198907527027, Press = 2.99746710216542
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13104.118   -13104.118   -13256.413   -13256.413    294.62528    294.62528    67258.295    67258.295    1342.4388    1342.4388 
   16000   -13102.983   -13102.983   -13255.918   -13255.918     295.8615     295.8615    67559.632    67559.632   -1486.1476   -1486.1476 
Loop time of 234.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.102 hours/ns, 4.267 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    | 233.45     | 233.45     | 233.45     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11404    | 0.11404    | 0.11404    |   0.0 |  0.05
Output  | 0.00018161 | 0.00018161 | 0.00018161 |   0.0 |  0.00
Modify  | 0.70616    | 0.70616    | 0.70616    |   0.0 |  0.30
Other   |            | 0.09445    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4097.00 ave        4097 max        4097 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:      215076.0 ave      215076 max      215076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215076
Ave neighs/atom = 53.769000
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 = 293.397109537063, Press = 0.10565785345988
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13102.983   -13102.983   -13255.918   -13255.918     295.8615     295.8615    67559.632    67559.632   -1486.1476   -1486.1476 
   17000   -13106.974   -13106.974   -13257.491   -13257.491     291.1854     291.1854    67331.209    67331.209    598.89785    598.89785 
Loop time of 232.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.479 hours/ns, 4.308 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    | 231.22     | 231.22     | 231.22     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11103    | 0.11103    | 0.11103    |   0.0 |  0.05
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.70281    | 0.70281    | 0.70281    |   0.0 |  0.30
Other   |            | 0.09473    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 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:      214862.0 ave      214862 max      214862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214862
Ave neighs/atom = 53.715500
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 = 293.475840317274, Press = 0.984130518450104
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13106.974   -13106.974   -13257.491   -13257.491     291.1854     291.1854    67331.209    67331.209    598.89785    598.89785 
   18000   -13097.877   -13097.877   -13251.586   -13251.586    297.36062    297.36062    67456.755    67456.755    -319.1142    -319.1142 
Loop time of 234.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.016 hours/ns, 4.272 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    | 233.14     | 233.14     | 233.14     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11395    | 0.11395    | 0.11395    |   0.0 |  0.05
Output  | 0.00017848 | 0.00017848 | 0.00017848 |   0.0 |  0.00
Modify  | 0.71028    | 0.71028    | 0.71028    |   0.0 |  0.30
Other   |            | 0.09507    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4050.00 ave        4050 max        4050 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:      215082.0 ave      215082 max      215082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215082
Ave neighs/atom = 53.770500
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 = 293.494775208677, Press = 1.48923309557378
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13097.877   -13097.877   -13251.586   -13251.586    297.36062    297.36062    67456.755    67456.755    -319.1142    -319.1142 
   19000   -13107.665   -13107.665   -13258.973   -13258.973    292.71486    292.71486    67348.278    67348.278    340.09149    340.09149 
Loop time of 236.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.693 hours/ns, 4.228 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    | 235.57     | 235.57     | 235.57     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11289    | 0.11289    | 0.11289    |   0.0 |  0.05
Output  | 0.00017689 | 0.00017689 | 0.00017689 |   0.0 |  0.00
Modify  | 0.72113    | 0.72113    | 0.72113    |   0.0 |  0.30
Other   |            | 0.09485    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 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:      214886.0 ave      214886 max      214886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214886
Ave neighs/atom = 53.721500
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 = 293.585337610091, Press = 0.531060770319126
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13107.665   -13107.665   -13258.973   -13258.973    292.71486    292.71486    67348.278    67348.278    340.09149    340.09149 
   20000   -13105.813   -13105.813   -13256.591   -13256.591     291.6896     291.6896    67480.992    67480.992   -793.15181   -793.15181 
Loop time of 232.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.505 hours/ns, 4.306 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    | 231.31     | 231.31     | 231.31     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11343    | 0.11343    | 0.11343    |   0.0 |  0.05
Output  | 0.00022798 | 0.00022798 | 0.00022798 |   0.0 |  0.00
Modify  | 0.70026    | 0.70026    | 0.70026    |   0.0 |  0.30
Other   |            | 0.09401    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4050.00 ave        4050 max        4050 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:      215062.0 ave      215062 max      215062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215062
Ave neighs/atom = 53.765500
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 = 293.488229314907, Press = 1.56403329565721
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13105.813   -13105.813   -13256.591   -13256.591     291.6896     291.6896    67480.992    67480.992   -793.15181   -793.15181 
   21000   -13104.465   -13104.465   -13257.026   -13257.026     295.1389     295.1389    67293.099    67293.099    980.46205    980.46205 
Loop time of 231.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.355 hours/ns, 4.316 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    | 230.77     | 230.77     | 230.77     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11365    | 0.11365    | 0.11365    |   0.0 |  0.05
Output  | 0.00017839 | 0.00017839 | 0.00017839 |   0.0 |  0.00
Modify  | 0.6993     | 0.6993     | 0.6993     |   0.0 |  0.30
Other   |            | 0.09413    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4084.00 ave        4084 max        4084 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:      214956.0 ave      214956 max      214956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214956
Ave neighs/atom = 53.739000
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 = 293.424382833859, Press = -1.15274961288743
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13104.465   -13104.465   -13257.026   -13257.026     295.1389     295.1389    67293.099    67293.099    980.46205    980.46205 
   22000   -13104.913   -13104.913   -13256.276   -13256.276    292.82259    292.82259    67460.694    67460.694   -591.49402   -591.49402 
Loop time of 233.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.806 hours/ns, 4.286 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    | 232.39     | 232.39     | 232.39     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11304    | 0.11304    | 0.11304    |   0.0 |  0.05
Output  | 0.000177   | 0.000177   | 0.000177   |   0.0 |  0.00
Modify  | 0.7066     | 0.7066     | 0.7066     |   0.0 |  0.30
Other   |            | 0.09523    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4057.00 ave        4057 max        4057 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:      215066.0 ave      215066 max      215066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215066
Ave neighs/atom = 53.766500
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 = 293.386679360015, Press = 2.34326718989118
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13104.913   -13104.913   -13256.276   -13256.276    292.82259    292.82259    67460.694    67460.694   -591.49402   -591.49402 
   23000   -13102.161   -13102.161   -13257.481   -13257.481    300.47745    300.47745    67375.919    67375.919    224.93731    224.93731 
Loop time of 232.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.552 hours/ns, 4.303 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    | 231.48     | 231.48     | 231.48     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11324    | 0.11324    | 0.11324    |   0.0 |  0.05
Output  | 0.00017906 | 0.00017906 | 0.00017906 |   0.0 |  0.00
Modify  | 0.70113    | 0.70113    | 0.70113    |   0.0 |  0.30
Other   |            | 0.09446    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4070.00 ave        4070 max        4070 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:      214964.0 ave      214964 max      214964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214964
Ave neighs/atom = 53.741000
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 = 293.426995654684, Press = -0.725532238904026
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13102.161   -13102.161   -13257.481   -13257.481    300.47745    300.47745    67375.919    67375.919    224.93731    224.93731 
   24000   -13105.242   -13105.242   -13256.079   -13256.079    291.80311    291.80311    67405.084    67405.084   -58.758048   -58.758048 
Loop time of 229.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.731 hours/ns, 4.359 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    | 228.54     | 228.54     | 228.54     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11199    | 0.11199    | 0.11199    |   0.0 |  0.05
Output  | 0.00017669 | 0.00017669 | 0.00017669 |   0.0 |  0.00
Modify  | 0.68675    | 0.68675    | 0.68675    |   0.0 |  0.30
Other   |            | 0.09336    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4086.00 ave        4086 max        4086 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:      215032.0 ave      215032 max      215032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215032
Ave neighs/atom = 53.758000
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 = 293.402815176519, Press = 1.33891188578805
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13105.242   -13105.242   -13256.079   -13256.079    291.80311    291.80311    67405.084    67405.084   -58.758048   -58.758048 
   25000   -13100.612   -13100.612   -13255.022   -13255.022    298.71638    298.71638      67409.2      67409.2    -33.25174    -33.25174 
Loop time of 231.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.376 hours/ns, 4.315 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    | 230.85     | 230.85     | 230.85     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11304    | 0.11304    | 0.11304    |   0.0 |  0.05
Output  | 0.00018242 | 0.00018242 | 0.00018242 |   0.0 |  0.00
Modify  | 0.69808    | 0.69808    | 0.69808    |   0.0 |  0.30
Other   |            | 0.09391    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4046.00 ave        4046 max        4046 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:      215046.0 ave      215046 max      215046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215046
Ave neighs/atom = 53.761500
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 = 293.475817349669, Press = 0.0674275344337466
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13100.612   -13100.612   -13255.022   -13255.022    298.71638    298.71638      67409.2      67409.2    -33.25174    -33.25174 
   26000   -13102.644   -13102.644    -13256.71    -13256.71    298.05065    298.05065    67400.468    67400.468    5.7506922    5.7506922 
Loop time of 231.035 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.176 hours/ns, 4.328 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    | 230.14     | 230.14     | 230.14     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11166    | 0.11166    | 0.11166    |   0.0 |  0.05
Output  | 0.00017565 | 0.00017565 | 0.00017565 |   0.0 |  0.00
Modify  | 0.68984    | 0.68984    | 0.68984    |   0.0 |  0.30
Other   |            | 0.09397    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4074.00 ave        4074 max        4074 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:      215010.0 ave      215010 max      215010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215010
Ave neighs/atom = 53.752500
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 = 293.452141458848, Press = 0.741821182473948
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13102.644   -13102.644    -13256.71    -13256.71    298.05065    298.05065    67400.468    67400.468    5.7506922    5.7506922 
   27000   -13107.227   -13107.227   -13257.562   -13257.562    290.83299    290.83299    67395.542    67395.542   -52.625582   -52.625582 
Loop time of 233.379 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.827 hours/ns, 4.285 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    | 232.46     | 232.46     | 232.46     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11474    | 0.11474    | 0.11474    |   0.0 |  0.05
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.70956    | 0.70956    | 0.70956    |   0.0 |  0.30
Other   |            | 0.09376    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4064.00 ave        4064 max        4064 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:      214980.0 ave      214980 max      214980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214980
Ave neighs/atom = 53.745000
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 = 293.465108999626, Press = 0.320235738041676
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13107.227   -13107.227   -13257.562   -13257.562    290.83299    290.83299    67395.542    67395.542   -52.625582   -52.625582 
   28000   -13100.963   -13100.963   -13255.784   -13255.784    299.51183    299.51183    67405.386    67405.386   -9.1046475   -9.1046475 
Loop time of 231.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.250 hours/ns, 4.323 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    | 230.39     | 230.39     | 230.39     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.111      | 0.111      | 0.111      |   0.0 |  0.05
Output  | 0.00020268 | 0.00020268 | 0.00020268 |   0.0 |  0.00
Modify  | 0.69772    | 0.69772    | 0.69772    |   0.0 |  0.30
Other   |            | 0.09514    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4081.00 ave        4081 max        4081 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:      214942.0 ave      214942 max      214942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214942
Ave neighs/atom = 53.735500
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 = 293.494266634123, Press = 0.33378197249287
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13100.963   -13100.963   -13255.784   -13255.784    299.51183    299.51183    67405.386    67405.386   -9.1046475   -9.1046475 
   29000   -13104.486   -13104.486   -13258.084   -13258.084    297.14693    297.14693    67420.514    67420.514   -263.35842   -263.35842 
Loop time of 230.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.965 hours/ns, 4.343 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    | 229.38     | 229.38     | 229.38     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10932    | 0.10932    | 0.10932    |   0.0 |  0.05
Output  | 0.00018078 | 0.00018078 | 0.00018078 |   0.0 |  0.00
Modify  | 0.69112    | 0.69112    | 0.69112    |   0.0 |  0.30
Other   |            | 0.09259    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4041.00 ave        4041 max        4041 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:      214978.0 ave      214978 max      214978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214978
Ave neighs/atom = 53.744500
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 = 293.535315832592, Press = 0.783704605099847
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13104.486   -13104.486   -13258.084   -13258.084    297.14693    297.14693    67420.514    67420.514   -263.35842   -263.35842 
   30000   -13101.939   -13101.939   -13254.114   -13254.114    294.39266    294.39266    67384.796    67384.796    213.85926    213.85926 
Loop time of 232.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.371 ns/day, 64.688 hours/ns, 4.294 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    | 231.96     | 231.96     | 231.96     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11159    | 0.11159    | 0.11159    |   0.0 |  0.05
Output  | 0.00044866 | 0.00044866 | 0.00044866 |   0.0 |  0.00
Modify  | 0.70769    | 0.70769    | 0.70769    |   0.0 |  0.30
Other   |            | 0.09437    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4070.00 ave        4070 max        4070 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:      215004.0 ave      215004 max      215004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215004
Ave neighs/atom = 53.751000
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 = 293.532045641471, Press = -0.419352355554671
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13101.939   -13101.939   -13254.114   -13254.114    294.39266    294.39266    67384.796    67384.796    213.85926    213.85926 
   31000   -13106.736   -13106.736   -13259.041   -13259.041    294.64538    294.64538    67417.121    67417.121   -303.68728   -303.68728 
Loop time of 233.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.823 hours/ns, 4.285 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    | 232.45     | 232.45     | 232.45     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11142    | 0.11142    | 0.11142    |   0.0 |  0.05
Output  | 0.00017826 | 0.00017826 | 0.00017826 |   0.0 |  0.00
Modify  | 0.7059     | 0.7059     | 0.7059     |   0.0 |  0.30
Other   |            | 0.09494    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4081.00 ave        4081 max        4081 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:      214912.0 ave      214912 max      214912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214912
Ave neighs/atom = 53.728000
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 = 293.470515857523, Press = 1.59053474075085
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13106.736   -13106.736   -13259.041   -13259.041    294.64538    294.64538    67417.121    67417.121   -303.68728   -303.68728 
   32000   -13103.809   -13103.809   -13256.803   -13256.803    295.97814    295.97814    67399.287    67399.287   -19.083655   -19.083655 
Loop time of 228.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.480 hours/ns, 4.376 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    | 227.64     | 227.64     | 227.64     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10888    | 0.10888    | 0.10888    |   0.0 |  0.05
Output  | 0.00017759 | 0.00017759 | 0.00017759 |   0.0 |  0.00
Modify  | 0.68551    | 0.68551    | 0.68551    |   0.0 |  0.30
Other   |            | 0.09344    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4104.00 ave        4104 max        4104 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:      214992.0 ave      214992 max      214992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214992
Ave neighs/atom = 53.748000
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 = 293.414695127942, Press = -1.50490295593417
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13103.809   -13103.809   -13256.803   -13256.803    295.97814    295.97814    67399.287    67399.287   -19.083655   -19.083655 
   33000   -13113.159   -13113.159   -13258.816   -13258.816    281.78236    281.78236    67344.211    67344.211    341.02693    341.02693 
Loop time of 232.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.371 ns/day, 64.619 hours/ns, 4.299 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    | 231.72     | 231.72     | 231.72     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11       | 0.11       | 0.11       |   0.0 |  0.05
Output  | 0.00017579 | 0.00017579 | 0.00017579 |   0.0 |  0.00
Modify  | 0.70557    | 0.70557    | 0.70557    |   0.0 |  0.30
Other   |            | 0.09414    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4042.00 ave        4042 max        4042 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:      215006.0 ave      215006 max      215006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215006
Ave neighs/atom = 53.751500
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 = 293.351702583317, Press = 1.31301828066952
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13113.159   -13113.159   -13258.816   -13258.816    281.78236    281.78236    67344.211    67344.211    341.02693    341.02693 
   34000   -13102.243   -13102.243   -13254.911   -13254.911    295.34683    295.34683    67431.927    67431.927   -250.30575   -250.30575 
Loop time of 230.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.114 hours/ns, 4.333 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    | 229.91     | 229.91     | 229.91     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11025    | 0.11025    | 0.11025    |   0.0 |  0.05
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.69783    | 0.69783    | 0.69783    |   0.0 |  0.30
Other   |            | 0.09407    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4071.00 ave        4071 max        4071 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:      215026.0 ave      215026 max      215026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215026
Ave neighs/atom = 53.756500
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
67399.1267531061

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0