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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.619999974966049*${_u_distance}
variable latticeconst_converted equal 3.619999974966049*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61999997496605
Lattice spacing in x,y,z = 3.6200000 3.6200000 3.6200000
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 (36.200000 36.200000 36.200000)
  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 (36.200000 36.200000 36.200000)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Cu__MO_313717476091_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47437.9270158353 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_313717476091_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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14008.467   -14008.467       -14160       -14160       293.15       293.15    47437.927    47437.927    3411.9444    3411.9444 
    1000   -13880.493   -13880.493   -14029.279   -14029.279    287.83596    287.83596    47851.295    47851.295   -643.07868   -643.07868 
Loop time of 196.463 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.573 hours/ns, 5.090 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    | 195.54     | 195.54     | 195.54     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15549    | 0.15549    | 0.15549    |   0.0 |  0.08
Output  | 0.00026897 | 0.00026897 | 0.00026897 |   0.0 |  0.00
Modify  | 0.66943    | 0.66943    | 0.66943    |   0.0 |  0.34
Other   |            | 0.09801    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13880.493   -13880.493   -14029.279   -14029.279    287.83596    287.83596    47851.295    47851.295   -643.07868   -643.07868 
    2000   -13871.841   -13871.841   -14023.975   -14023.975    294.31368    294.31368     47800.44     47800.44    387.63106    387.63106 
Loop time of 203.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.510 hours/ns, 4.916 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    | 202.52     | 202.52     | 202.52     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.07
Output  | 0.00025931 | 0.00025931 | 0.00025931 |   0.0 |  0.00
Modify  | 0.6634     | 0.6634     | 0.6634     |   0.0 |  0.33
Other   |            | 0.09819    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311622.0 ave      311622 max      311622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311622
Ave neighs/atom = 77.905500
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13871.841   -13871.841   -14023.975   -14023.975    294.31368    294.31368     47800.44     47800.44    387.63106    387.63106 
    3000   -13876.164   -13876.164   -14028.251   -14028.251    294.22217    294.22217    47790.447    47790.447    604.87794    604.87794 
Loop time of 203.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.541 hours/ns, 4.913 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    | 202.63     | 202.63     | 202.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15306    | 0.15306    | 0.15306    |   0.0 |  0.08
Output  | 0.00020793 | 0.00020793 | 0.00020793 |   0.0 |  0.00
Modify  | 0.66628    | 0.66628    | 0.66628    |   0.0 |  0.33
Other   |            | 0.09804    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311574.0 ave      311574 max      311574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311574
Ave neighs/atom = 77.893500
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13876.164   -13876.164   -14028.251   -14028.251    294.22217    294.22217    47790.447    47790.447    604.87794    604.87794 
    4000   -13878.322   -13878.322   -14028.623   -14028.623     290.7675     290.7675    47826.157    47826.157   -298.11588   -298.11588 
Loop time of 203.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.444 hours/ns, 4.921 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    | 202.28     | 202.28     | 202.28     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15367    | 0.15367    | 0.15367    |   0.0 |  0.08
Output  | 0.00021826 | 0.00021826 | 0.00021826 |   0.0 |  0.00
Modify  | 0.66745    | 0.66745    | 0.66745    |   0.0 |  0.33
Other   |            | 0.09857    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311588.0 ave      311588 max      311588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311588
Ave neighs/atom = 77.897000
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13878.322   -13878.322   -14028.623   -14028.623     290.7675     290.7675    47826.157    47826.157   -298.11588   -298.11588 
    5000   -13872.708   -13872.708   -14026.866   -14026.866    298.22775    298.22775    47795.237    47795.237    602.84225    602.84225 
Loop time of 204.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.802 hours/ns, 4.890 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    | 203.56     | 203.56     | 203.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15359    | 0.15359    | 0.15359    |   0.0 |  0.08
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.67318    | 0.67318    | 0.67318    |   0.0 |  0.33
Other   |            | 0.09912    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311606.0 ave      311606 max      311606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311606
Ave neighs/atom = 77.901500
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 = 295.372143995553, Press = -193.776980359784
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13872.708   -13872.708   -14026.866   -14026.866    298.22775    298.22775    47795.237    47795.237    602.84225    602.84225 
    6000   -13874.758   -13874.758   -14025.019   -14025.019    290.68828    290.68828    47856.304    47856.304   -1342.5928   -1342.5928 
Loop time of 204.87 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.908 hours/ns, 4.881 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    | 203.92     | 203.92     | 203.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15428    | 0.15428    | 0.15428    |   0.0 |  0.08
Output  | 0.00018121 | 0.00018121 | 0.00018121 |   0.0 |  0.00
Modify  | 0.69557    | 0.69557    | 0.69557    |   0.0 |  0.34
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311626.0 ave      311626 max      311626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311626
Ave neighs/atom = 77.906500
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.050173705051, Press = 11.9831416406738
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13874.758   -13874.758   -14025.019   -14025.019    290.68828    290.68828    47856.304    47856.304   -1342.5928   -1342.5928 
    7000   -13878.444   -13878.444   -14028.004   -14028.004    289.33489    289.33489    47763.696    47763.696    1398.5279    1398.5279 
Loop time of 203.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.564 hours/ns, 4.911 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    | 202.69     | 202.69     | 202.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15183    | 0.15183    | 0.15183    |   0.0 |  0.07
Output  | 0.00022687 | 0.00022687 | 0.00022687 |   0.0 |  0.00
Modify  | 0.69007    | 0.69007    | 0.69007    |   0.0 |  0.34
Other   |            | 0.09869    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311580.0 ave      311580 max      311580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311580
Ave neighs/atom = 77.895000
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.215343028548, Press = -22.1315164397945
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13878.444   -13878.444   -14028.004   -14028.004    289.33489    289.33489    47763.696    47763.696    1398.5279    1398.5279 
    8000   -13879.577   -13879.577   -14029.416   -14029.416    289.87393    289.87393    47833.127    47833.127   -482.88789   -482.88789 
Loop time of 203.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.488 hours/ns, 4.918 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    | 202.41     | 202.41     | 202.41     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.08
Output  | 0.00017875 | 0.00017875 | 0.00017875 |   0.0 |  0.00
Modify  | 0.69603    | 0.69603    | 0.69603    |   0.0 |  0.34
Other   |            | 0.09862    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311606.0 ave      311606 max      311606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311606
Ave neighs/atom = 77.901500
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.115118025196, Press = 11.6664489330778
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13879.577   -13879.577   -14029.416   -14029.416    289.87393    289.87393    47833.127    47833.127   -482.88789   -482.88789 
    9000   -13875.772   -13875.772   -14026.377   -14026.377    291.35495    291.35495    47805.381    47805.381     142.9385     142.9385 
Loop time of 202.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.267 hours/ns, 4.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.62     | 201.62     | 201.62     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15302    | 0.15302    | 0.15302    |   0.0 |  0.08
Output  | 0.00017796 | 0.00017796 | 0.00017796 |   0.0 |  0.00
Modify  | 0.68739    | 0.68739    | 0.68739    |   0.0 |  0.34
Other   |            | 0.09816    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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 = 77.898500
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.078853113989, Press = -11.7201947501434
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13875.772   -13875.772   -14026.377   -14026.377    291.35495    291.35495    47805.381    47805.381     142.9385     142.9385 
   10000   -13873.411   -13873.411   -14025.915   -14025.915    295.02855    295.02855    47814.354    47814.354    17.918978    17.918978 
Loop time of 203.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.422 hours/ns, 4.923 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    | 202.18     | 202.18     | 202.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.154      | 0.154      | 0.154      |   0.0 |  0.08
Output  | 0.0001806  | 0.0001806  | 0.0001806  |   0.0 |  0.00
Modify  | 0.69178    | 0.69178    | 0.69178    |   0.0 |  0.34
Other   |            | 0.09862    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311584.0 ave      311584 max      311584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311584
Ave neighs/atom = 77.896000
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.063272725507, Press = -1.67034221205255
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13873.411   -13873.411   -14025.915   -14025.915    295.02855    295.02855    47814.354    47814.354    17.918978    17.918978 
   11000   -13879.995   -13879.995   -14027.487   -14027.487    285.33403    285.33403    47808.072    47808.072   -120.37906   -120.37906 
Loop time of 204.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.736 hours/ns, 4.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    | 203.3      | 203.3      | 203.3      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15303    | 0.15303    | 0.15303    |   0.0 |  0.07
Output  | 0.00021697 | 0.00021697 | 0.00021697 |   0.0 |  0.00
Modify  | 0.69976    | 0.69976    | 0.69976    |   0.0 |  0.34
Other   |            | 0.09842    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311496.0 ave      311496 max      311496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311496
Ave neighs/atom = 77.874000
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.837143587769, Press = 0.788216365961676
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13879.995   -13879.995   -14027.487   -14027.487    285.33403    285.33403    47808.072    47808.072   -120.37906   -120.37906 
   12000   -13877.386   -13877.386   -14025.918   -14025.918    287.34431    287.34431    47781.446    47781.446     696.7262     696.7262 
Loop time of 203.991 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.664 hours/ns, 4.902 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    | 203.04     | 203.04     | 203.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.07
Output  | 0.00018383 | 0.00018383 | 0.00018383 |   0.0 |  0.00
Modify  | 0.69415    | 0.69415    | 0.69415    |   0.0 |  0.34
Other   |            | 0.09894    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311578.0 ave      311578 max      311578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311578
Ave neighs/atom = 77.894500
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.778438489169, Press = -10.5305520617221
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13877.386   -13877.386   -14025.918   -14025.918    287.34431    287.34431    47781.446    47781.446     696.7262     696.7262 
   13000   -13874.404   -13874.404   -14027.563   -14027.563    296.29624    296.29624    47807.791    47807.791    17.540688    17.540688 
Loop time of 203.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.566 hours/ns, 4.911 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    | 202.69     | 202.69     | 202.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15398    | 0.15398    | 0.15398    |   0.0 |  0.08
Output  | 0.00021867 | 0.00021867 | 0.00021867 |   0.0 |  0.00
Modify  | 0.69345    | 0.69345    | 0.69345    |   0.0 |  0.34
Other   |            | 0.09863    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311570.0 ave      311570 max      311570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311570
Ave neighs/atom = 77.892500
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.798805547712, Press = 7.78626113566211
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13874.404   -13874.404   -14027.563   -14027.563    296.29624    296.29624    47807.791    47807.791    17.540688    17.540688 
   14000   -13871.554   -13871.554   -14026.288   -14026.288    299.34419    299.34419    47828.741    47828.741   -217.02309   -217.02309 
Loop time of 203.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.633 hours/ns, 4.905 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    | 202.94     | 202.94     | 202.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15238    | 0.15238    | 0.15238    |   0.0 |  0.07
Output  | 0.00018099 | 0.00018099 | 0.00018099 |   0.0 |  0.00
Modify  | 0.69247    | 0.69247    | 0.69247    |   0.0 |  0.34
Other   |            | 0.09856    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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 = 77.897500
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.930741090992, Press = -5.48648733280343
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13871.554   -13871.554   -14026.288   -14026.288    299.34419    299.34419    47828.741    47828.741   -217.02309   -217.02309 
   15000   -13877.368   -13877.368   -14026.685   -14026.685    288.86327    288.86327    47820.097    47820.097   -360.72334   -360.72334 
Loop time of 204.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.779 hours/ns, 4.892 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    | 203.45     | 203.45     | 203.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1532     | 0.1532     | 0.1532     |   0.0 |  0.07
Output  | 0.00018208 | 0.00018208 | 0.00018208 |   0.0 |  0.00
Modify  | 0.698      | 0.698      | 0.698      |   0.0 |  0.34
Other   |            | 0.09882    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311586.0 ave      311586 max      311586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311586
Ave neighs/atom = 77.896500
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.155365583626, Press = 2.19820219917509
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13877.368   -13877.368   -14026.685   -14026.685    288.86327    288.86327    47820.097    47820.097   -360.72334   -360.72334 
   16000   -13880.067   -13880.067    -14028.84    -14028.84    287.81212    287.81212    47835.104    47835.104   -536.45256   -536.45256 
Loop time of 203.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.472 hours/ns, 4.919 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    | 202.35     | 202.35     | 202.35     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1538     | 0.1538     | 0.1538     |   0.0 |  0.08
Output  | 0.00018218 | 0.00018218 | 0.00018218 |   0.0 |  0.00
Modify  | 0.6928     | 0.6928     | 0.6928     |   0.0 |  0.34
Other   |            | 0.09907    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311506.0 ave      311506 max      311506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311506
Ave neighs/atom = 77.876500
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.181647262679, Press = -4.13224391313889
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13880.067   -13880.067    -14028.84    -14028.84    287.81212    287.81212    47835.104    47835.104   -536.45256   -536.45256 
   17000   -13874.671   -13874.671   -14027.424   -14027.424    295.51262    295.51262    47806.869    47806.869     258.1885     258.1885 
Loop time of 203.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.645 hours/ns, 4.904 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    | 202.98     | 202.98     | 202.98     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1531     | 0.1531     | 0.1531     |   0.0 |  0.08
Output  | 0.00017956 | 0.00017956 | 0.00017956 |   0.0 |  0.00
Modify  | 0.69395    | 0.69395    | 0.69395    |   0.0 |  0.34
Other   |            | 0.09863    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311608.0 ave      311608 max      311608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311608
Ave neighs/atom = 77.902000
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.144155402165, Press = 1.05779738236965
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13874.671   -13874.671   -14027.424   -14027.424    295.51262    295.51262    47806.869    47806.869     258.1885     258.1885 
   18000   -13870.263   -13870.263    -14024.48    -14024.48    298.34263    298.34263    47849.701    47849.701   -1084.5816   -1084.5816 
Loop time of 204.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.937 hours/ns, 4.879 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.02     | 204.02     | 204.02     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15363    | 0.15363    | 0.15363    |   0.0 |  0.07
Output  | 0.00018037 | 0.00018037 | 0.00018037 |   0.0 |  0.00
Modify  | 0.70298    | 0.70298    | 0.70298    |   0.0 |  0.34
Other   |            | 0.09818    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311584.0 ave      311584 max      311584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311584
Ave neighs/atom = 77.896000
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.130704477698, Press = -4.14509831616221
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13870.263   -13870.263    -14024.48    -14024.48    298.34263    298.34263    47849.701    47849.701   -1084.5816   -1084.5816 
   19000   -13873.239   -13873.239   -14027.708   -14027.708     298.8308     298.8308    47730.261    47730.261    2224.3336    2224.3336 
Loop time of 204.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.845 hours/ns, 4.887 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    | 203.69     | 203.69     | 203.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15234    | 0.15234    | 0.15234    |   0.0 |  0.07
Output  | 0.00018075 | 0.00018075 | 0.00018075 |   0.0 |  0.00
Modify  | 0.6978     | 0.6978     | 0.6978     |   0.0 |  0.34
Other   |            | 0.0988     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311442.0 ave      311442 max      311442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311442
Ave neighs/atom = 77.860500
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.214020591166, Press = 2.37485747627082
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13873.239   -13873.239   -14027.708   -14027.708     298.8308     298.8308    47730.261    47730.261    2224.3336    2224.3336 
   20000    -13878.52    -13878.52   -14029.062   -14029.062    291.23378    291.23378    47864.816    47864.816   -1459.5636   -1459.5636 
Loop time of 203.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.642 hours/ns, 4.904 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    | 202.96     | 202.96     | 202.96     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1538     | 0.1538     | 0.1538     |   0.0 |  0.08
Output  | 0.00018181 | 0.00018181 | 0.00018181 |   0.0 |  0.00
Modify  | 0.69505    | 0.69505    | 0.69505    |   0.0 |  0.34
Other   |            | 0.09851    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311600.0 ave      311600 max      311600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311600
Ave neighs/atom = 77.900000
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.136316083483, Press = -2.36481131619725
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -13878.52    -13878.52   -14029.062   -14029.062    291.23378    291.23378    47864.816    47864.816   -1459.5636   -1459.5636 
   21000   -13875.866   -13875.866    -14029.29    -14029.29    296.80793    296.80793     47755.63     47755.63    1435.3551    1435.3551 
Loop time of 203.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.506 hours/ns, 4.916 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    | 202.48     | 202.48     | 202.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15352    | 0.15352    | 0.15352    |   0.0 |  0.08
Output  | 0.00018401 | 0.00018401 | 0.00018401 |   0.0 |  0.00
Modify  | 0.68904    | 0.68904    | 0.68904    |   0.0 |  0.34
Other   |            | 0.09817    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311564.0 ave      311564 max      311564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311564
Ave neighs/atom = 77.891000
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.072079061041, Press = 0.220232680828304
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13875.866   -13875.866    -14029.29    -14029.29    296.80793    296.80793     47755.63     47755.63    1435.3551    1435.3551 
   22000   -13874.785   -13874.785   -14025.458   -14025.458     291.4877     291.4877    47872.546    47872.546   -1690.2553   -1690.2553 
Loop time of 204.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.926 hours/ns, 4.880 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    | 203.98     | 203.98     | 203.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15433    | 0.15433    | 0.15433    |   0.0 |  0.08
Output  | 0.00018378 | 0.00018378 | 0.00018378 |   0.0 |  0.00
Modify  | 0.70189    | 0.70189    | 0.70189    |   0.0 |  0.34
Other   |            | 0.09871    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311630.0 ave      311630 max      311630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311630
Ave neighs/atom = 77.907500
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.115151234095, Press = -0.532903715322188
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13874.785   -13874.785   -14025.458   -14025.458     291.4877     291.4877    47872.546    47872.546   -1690.2553   -1690.2553 
   23000   -13873.418   -13873.418   -14028.601   -14028.601    300.21226    300.21226    47748.915    47748.915    1838.1265    1838.1265 
Loop time of 202.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.334 hours/ns, 4.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.86     | 201.86     | 201.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15264    | 0.15264    | 0.15264    |   0.0 |  0.08
Output  | 0.00018508 | 0.00018508 | 0.00018508 |   0.0 |  0.00
Modify  | 0.69013    | 0.69013    | 0.69013    |   0.0 |  0.34
Other   |            | 0.09789    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311506.0 ave      311506 max      311506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311506
Ave neighs/atom = 77.876500
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.189967151019, Press = -0.747881180309853
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13873.418   -13873.418   -14028.601   -14028.601    300.21226    300.21226    47748.915    47748.915    1838.1265    1838.1265 
   24000    -13874.77    -13874.77   -14027.188   -14027.188    294.86315    294.86315    47823.445    47823.445   -408.43676   -408.43676 
Loop time of 204.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.781 hours/ns, 4.892 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    | 203.46     | 203.46     | 203.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15598    | 0.15598    | 0.15598    |   0.0 |  0.08
Output  | 0.00029447 | 0.00029447 | 0.00029447 |   0.0 |  0.00
Modify  | 0.70145    | 0.70145    | 0.70145    |   0.0 |  0.34
Other   |            | 0.09868    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311606.0 ave      311606 max      311606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311606
Ave neighs/atom = 77.901500
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.168313505987, Press = 0.351855802462838
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -13874.77    -13874.77   -14027.188   -14027.188    294.86315    294.86315    47823.445    47823.445   -408.43676   -408.43676 
   25000   -13874.035   -13874.035   -14023.144   -14023.144    288.46233    288.46233    47820.832    47820.832   -233.55845   -233.55845 
Loop time of 203.436 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.510 hours/ns, 4.916 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    | 202.49     | 202.49     | 202.49     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15402    | 0.15402    | 0.15402    |   0.0 |  0.08
Output  | 0.00018103 | 0.00018103 | 0.00018103 |   0.0 |  0.00
Modify  | 0.69101    | 0.69101    | 0.69101    |   0.0 |  0.34
Other   |            | 0.09787    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311544.0 ave      311544 max      311544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311544
Ave neighs/atom = 77.886000
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.170308949774, Press = -1.65023366732174
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13874.035   -13874.035   -14023.144   -14023.144    288.46233    288.46233    47820.832    47820.832   -233.55845   -233.55845 
   26000   -13875.605   -13875.605   -14027.042   -14027.042    292.96517    292.96517    47787.226    47787.226    421.51506    421.51506 
Loop time of 203.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.656 hours/ns, 4.903 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    | 203.02     | 203.02     | 203.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15481    | 0.15481    | 0.15481    |   0.0 |  0.08
Output  | 0.00018213 | 0.00018213 | 0.00018213 |   0.0 |  0.00
Modify  | 0.69195    | 0.69195    | 0.69195    |   0.0 |  0.34
Other   |            | 0.0978     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311532.0 ave      311532 max      311532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311532
Ave neighs/atom = 77.883000
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.254648688926, Press = 0.546081169246745
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13875.605   -13875.605   -14027.042   -14027.042    292.96517    292.96517    47787.226    47787.226    421.51506    421.51506 
   27000   -13876.227   -13876.227   -14025.449   -14025.449    288.68063    288.68063    47868.142    47868.142   -1635.0827   -1635.0827 
Loop time of 202.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.305 hours/ns, 4.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.76     | 201.76     | 201.76     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15293    | 0.15293    | 0.15293    |   0.0 |  0.08
Output  | 0.0001802  | 0.0001802  | 0.0001802  |   0.0 |  0.00
Modify  | 0.6928     | 0.6928     | 0.6928     |   0.0 |  0.34
Other   |            | 0.09807    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311582.0 ave      311582 max      311582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311582
Ave neighs/atom = 77.895500
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.278787383087, Press = -1.78017536832992
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13876.227   -13876.227   -14025.449   -14025.449    288.68063    288.68063    47868.142    47868.142   -1635.0827   -1635.0827 
   28000   -13870.201   -13870.201   -14025.005   -14025.005    299.47925    299.47925    47761.626    47761.626    1668.1333    1668.1333 
Loop time of 204.152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.709 hours/ns, 4.898 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    | 203.21     | 203.21     | 203.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15349    | 0.15349    | 0.15349    |   0.0 |  0.08
Output  | 0.00018042 | 0.00018042 | 0.00018042 |   0.0 |  0.00
Modify  | 0.69318    | 0.69318    | 0.69318    |   0.0 |  0.34
Other   |            | 0.09883    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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 = 77.879000
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.340870267734, Press = 0.289328197494911
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13870.201   -13870.201   -14025.005   -14025.005    299.47925    299.47925    47761.626    47761.626    1668.1333    1668.1333 
   29000   -13874.809   -13874.809   -14026.711   -14026.711    293.86303    293.86303    47842.963    47842.963   -691.65709   -691.65709 
Loop time of 203.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.655 hours/ns, 4.903 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    | 203.02     | 203.02     | 203.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15222    | 0.15222    | 0.15222    |   0.0 |  0.07
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.68774    | 0.68774    | 0.68774    |   0.0 |  0.34
Other   |            | 0.09863    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311598.0 ave      311598 max      311598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311598
Ave neighs/atom = 77.899500
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.298565006075, Press = -0.828206914002657
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13874.809   -13874.809   -14026.711   -14026.711    293.86303    293.86303    47842.963    47842.963   -691.65709   -691.65709 
   30000   -13878.215   -13878.215   -14029.662   -14029.662    292.98275    292.98275    47795.243    47795.243    535.74363    535.74363 
Loop time of 202.465 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.240 hours/ns, 4.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.53     | 201.53     | 201.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15071    | 0.15071    | 0.15071    |   0.0 |  0.07
Output  | 0.00040633 | 0.00040633 | 0.00040633 |   0.0 |  0.00
Modify  | 0.68828    | 0.68828    | 0.68828    |   0.0 |  0.34
Other   |            | 0.09851    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311546.0 ave      311546 max      311546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311546
Ave neighs/atom = 77.886500
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.216342970917, Press = -0.32284597210663
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13878.215   -13878.215   -14029.662   -14029.662    292.98275    292.98275    47795.243    47795.243    535.74363    535.74363 
   31000   -13878.414   -13878.414    -14027.23    -14027.23    287.89339    287.89339    47829.348    47829.348   -515.42681   -515.42681 
Loop time of 205.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.945 hours/ns, 4.878 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    | 204.05     | 204.05     | 204.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15289    | 0.15289    | 0.15289    |   0.0 |  0.07
Output  | 0.00017941 | 0.00017941 | 0.00017941 |   0.0 |  0.00
Modify  | 0.70154    | 0.70154    | 0.70154    |   0.0 |  0.34
Other   |            | 0.09898    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311648.0 ave      311648 max      311648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311648
Ave neighs/atom = 77.912000
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.187499267742, Press = -0.704478358849566
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13878.414   -13878.414    -14027.23    -14027.23    287.89339    287.89339    47829.348    47829.348   -515.42681   -515.42681 
   32000   -13873.961   -13873.961   -14024.453   -14024.453    291.13627    291.13627    47765.432    47765.432    1195.7915    1195.7915 
Loop time of 205.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.969 hours/ns, 4.876 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    | 204.13     | 204.13     | 204.13     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15335    | 0.15335    | 0.15335    |   0.0 |  0.07
Output  | 0.00022285 | 0.00022285 | 0.00022285 |   0.0 |  0.00
Modify  | 0.70289    | 0.70289    | 0.70289    |   0.0 |  0.34
Other   |            | 0.09916    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311536.0 ave      311536 max      311536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311536
Ave neighs/atom = 77.884000
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.177497991296, Press = -0.373641526055365
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13873.961   -13873.961   -14024.453   -14024.453    291.13627    291.13627    47765.432    47765.432    1195.7915    1195.7915 
   33000    -13872.93    -13872.93   -14025.568   -14025.568    295.28935    295.28935    47908.175    47908.175   -2681.4904   -2681.4904 
Loop time of 206.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.292 hours/ns, 4.848 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    | 205.29     | 205.29     | 205.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15315    | 0.15315    | 0.15315    |   0.0 |  0.07
Output  | 0.00017539 | 0.00017539 | 0.00017539 |   0.0 |  0.00
Modify  | 0.70742    | 0.70742    | 0.70742    |   0.0 |  0.34
Other   |            | 0.09983    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311454.0 ave      311454 max      311454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311454
Ave neighs/atom = 77.863500
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.160219657605, Press = -0.569309344939148
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -13872.93    -13872.93   -14025.568   -14025.568    295.28935    295.28935    47908.175    47908.175   -2681.4904   -2681.4904 
   34000   -13877.644   -13877.644   -14026.665   -14026.665    288.29052    288.29052    47738.423    47738.423    2008.6008    2008.6008 
Loop time of 205.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.080 hours/ns, 4.867 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    | 204.53     | 204.53     | 204.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15391    | 0.15391    | 0.15391    |   0.0 |  0.07
Output  | 0.00022193 | 0.00022193 | 0.00022193 |   0.0 |  0.00
Modify  | 0.70127    | 0.70127    | 0.70127    |   0.0 |  0.34
Other   |            | 0.09966    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311444.0 ave      311444 max      311444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311444
Ave neighs/atom = 77.861000
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.12477894271, Press = -0.679095428550659
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13877.644   -13877.644   -14026.665   -14026.665    288.29052    288.29052    47738.423    47738.423    2008.6008    2008.6008 
   35000   -13876.001   -13876.001   -14027.353   -14027.353    292.80141    292.80141    47837.872    47837.872   -854.61297   -854.61297 
Loop time of 203.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.591 hours/ns, 4.909 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    | 202.78     | 202.78     | 202.78     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15194    | 0.15194    | 0.15194    |   0.0 |  0.07
Output  | 0.00018039 | 0.00018039 | 0.00018039 |   0.0 |  0.00
Modify  | 0.69044    | 0.69044    | 0.69044    |   0.0 |  0.34
Other   |            | 0.09912    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311616.0 ave      311616 max      311616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311616
Ave neighs/atom = 77.904000
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.173403820658, Press = 0.961393354823287
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13876.001   -13876.001   -14027.353   -14027.353    292.80141    292.80141    47837.872    47837.872   -854.61297   -854.61297 
   36000   -13870.996   -13870.996   -14025.527   -14025.527    298.95055    298.95055    47795.753    47795.753     414.7787     414.7787 
Loop time of 204.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.678 hours/ns, 4.901 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    | 203.1      | 203.1      | 203.1      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15205    | 0.15205    | 0.15205    |   0.0 |  0.07
Output  | 0.00022169 | 0.00022169 | 0.00022169 |   0.0 |  0.00
Modify  | 0.68964    | 0.68964    | 0.68964    |   0.0 |  0.34
Other   |            | 0.09938    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311548.0 ave      311548 max      311548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311548
Ave neighs/atom = 77.887000
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.184337468306, Press = -0.705399295123401
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13870.996   -13870.996   -14025.527   -14025.527    298.95055    298.95055    47795.753    47795.753     414.7787     414.7787 
   37000   -13873.294   -13873.294   -14027.579   -14027.579    298.47337    298.47337    47790.307    47790.307    672.41828    672.41828 
Loop time of 204.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.865 hours/ns, 4.885 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    | 203.76     | 203.76     | 203.76     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15356    | 0.15356    | 0.15356    |   0.0 |  0.08
Output  | 0.00018198 | 0.00018198 | 0.00018198 |   0.0 |  0.00
Modify  | 0.70042    | 0.70042    | 0.70042    |   0.0 |  0.34
Other   |            | 0.09978    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      311598.0 ave      311598 max      311598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311598
Ave neighs/atom = 77.899500
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
47810.8967687729

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0