# 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 5.580486714839936*${_u_distance}
variable latticeconst_converted equal 5.580486714839936*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  5.58048671483994
Lattice spacing in x,y,z = 5.5804867 5.5804867 5.5804867
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 (55.804867 55.804867 55.804867)
  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 (55.804867 55.804867 55.804867)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Ca

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

kim interactions Ca
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JangSeolLee_2019_CaZnMg__MO_708495328010_001
pair_coeff * * Ca
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 40.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_708495328010_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -7187.791    -7187.791        -7360        -7360       333.15       333.15    173786.58    173786.58    1058.4204    1058.4204 
    1000   -7028.7305   -7028.7305   -7205.6838   -7205.6838    342.32816    342.32816    178735.84    178735.84   -374.75799   -374.75799 
Loop time of 197.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.833 hours/ns, 5.066 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.24     | 196.24     | 196.24     |   0.0 | 99.41
Neigh   | 0.30956    | 0.30956    | 0.30956    |   0.0 |  0.16
Comm    | 0.11309    | 0.11309    | 0.11309    |   0.0 |  0.06
Output  | 0.000266   | 0.000266   | 0.000266   |   0.0 |  0.00
Modify  | 0.64549    | 0.64549    | 0.64549    |   0.0 |  0.33
Other   |            | 0.08969    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3818.00 ave        3818 max        3818 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:      194604.0 ave      194604 max      194604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194604
Ave neighs/atom = 48.651000
Neighbor list builds = 9
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7028.7305   -7028.7305   -7205.6838   -7205.6838    342.32816    342.32816    178735.84    178735.84   -374.75799   -374.75799 
    2000   -7031.4309   -7031.4309   -7199.6964   -7199.6964    325.52104    325.52104    178262.26    178262.26    114.35475    114.35475 
Loop time of 195.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.172 hours/ns, 5.128 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.88     | 193.88     | 193.88     |   0.0 | 99.42
Neigh   | 0.30667    | 0.30667    | 0.30667    |   0.0 |  0.16
Comm    | 0.10916    | 0.10916    | 0.10916    |   0.0 |  0.06
Output  | 0.00021211 | 0.00021211 | 0.00021211 |   0.0 |  0.00
Modify  | 0.63259    | 0.63259    | 0.63259    |   0.0 |  0.32
Other   |            | 0.09027    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3820.00 ave        3820 max        3820 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:      195286.0 ave      195286 max      195286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195286
Ave neighs/atom = 48.821500
Neighbor list builds = 9
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7031.4309   -7031.4309   -7199.6964   -7199.6964    325.52104    325.52104    178262.26    178262.26    114.35475    114.35475 
    3000   -7038.2988   -7038.2988   -7204.7164   -7204.7164    321.94613    321.94613    178202.33    178202.33    95.635871    95.635871 
Loop time of 195.202 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.223 hours/ns, 5.123 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.06     | 194.06     | 194.06     |   0.0 | 99.42
Neigh   | 0.30642    | 0.30642    | 0.30642    |   0.0 |  0.16
Comm    | 0.11013    | 0.11013    | 0.11013    |   0.0 |  0.06
Output  | 0.00021237 | 0.00021237 | 0.00021237 |   0.0 |  0.00
Modify  | 0.63295    | 0.63295    | 0.63295    |   0.0 |  0.32
Other   |            | 0.09016    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3820.00 ave        3820 max        3820 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:      195438.0 ave      195438 max      195438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195438
Ave neighs/atom = 48.859500
Neighbor list builds = 9
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7038.2988   -7038.2988   -7204.7164   -7204.7164    321.94613    321.94613    178202.33    178202.33    95.635871    95.635871 
    4000   -7025.6077   -7025.6077   -7202.7864   -7202.7864    342.76422    342.76422    178469.74    178469.74    -59.21596    -59.21596 
Loop time of 195.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.196 hours/ns, 5.125 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.97     | 193.97     | 193.97     |   0.0 | 99.42
Neigh   | 0.30825    | 0.30825    | 0.30825    |   0.0 |  0.16
Comm    | 0.10921    | 0.10921    | 0.10921    |   0.0 |  0.06
Output  | 0.00021077 | 0.00021077 | 0.00021077 |   0.0 |  0.00
Modify  | 0.63332    | 0.63332    | 0.63332    |   0.0 |  0.32
Other   |            | 0.09007    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3824.00 ave        3824 max        3824 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:      195218.0 ave      195218 max      195218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195218
Ave neighs/atom = 48.804500
Neighbor list builds = 9
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7025.6077   -7025.6077   -7202.7864   -7202.7864    342.76422    342.76422    178469.74    178469.74    -59.21596    -59.21596 
    5000   -7036.1796   -7036.1796   -7210.5369   -7210.5369    337.30601    337.30601    178097.12    178097.12    93.253223    93.253223 
Loop time of 194.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.141 hours/ns, 5.131 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.77     | 193.77     | 193.77     |   0.0 | 99.41
Neigh   | 0.30626    | 0.30626    | 0.30626    |   0.0 |  0.16
Comm    | 0.10901    | 0.10901    | 0.10901    |   0.0 |  0.06
Output  | 0.00017628 | 0.00017628 | 0.00017628 |   0.0 |  0.00
Modify  | 0.63533    | 0.63533    | 0.63533    |   0.0 |  0.33
Other   |            | 0.08958    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3813.00 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      195466.0 ave      195466 max      195466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195466
Ave neighs/atom = 48.866500
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.809550976981, Press = -69.6311010401874
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -7036.1796   -7036.1796   -7210.5369   -7210.5369    337.30601    337.30601    178097.12    178097.12    93.253223    93.253223 
    6000   -7028.2234   -7028.2234   -7205.2011   -7205.2011    342.37536    342.37536    178693.01    178693.01   -331.95941   -331.95941 
Loop time of 194.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.139 hours/ns, 5.131 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.7      | 193.7      | 193.7      |   0.0 | 99.39
Neigh   | 0.34006    | 0.34006    | 0.34006    |   0.0 |  0.17
Comm    | 0.10995    | 0.10995    | 0.10995    |   0.0 |  0.06
Output  | 0.00022703 | 0.00022703 | 0.00022703 |   0.0 |  0.00
Modify  | 0.65668    | 0.65668    | 0.65668    |   0.0 |  0.34
Other   |            | 0.09028    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3816.00 ave        3816 max        3816 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:      194792.0 ave      194792 max      194792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194792
Ave neighs/atom = 48.698000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13546456137, Press = 9.74218671807795
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7028.2234   -7028.2234   -7205.2011   -7205.2011    342.37536    342.37536    178693.01    178693.01   -331.95941   -331.95941 
    7000   -7031.8786   -7031.8786   -7206.4371   -7206.4371    337.69521    337.69521    177849.56    177849.56    414.57641    414.57641 
Loop time of 195.064 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.185 hours/ns, 5.127 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.87     | 193.87     | 193.87     |   0.0 | 99.39
Neigh   | 0.34056    | 0.34056    | 0.34056    |   0.0 |  0.17
Comm    | 0.11038    | 0.11038    | 0.11038    |   0.0 |  0.06
Output  | 0.0001769  | 0.0001769  | 0.0001769  |   0.0 |  0.00
Modify  | 0.65556    | 0.65556    | 0.65556    |   0.0 |  0.34
Other   |            | 0.08993    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3817.00 ave        3817 max        3817 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:      195566.0 ave      195566 max      195566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195566
Ave neighs/atom = 48.891500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816655138088, Press = -2.60345304892943
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7031.8786   -7031.8786   -7206.4371   -7206.4371    337.69521    337.69521    177849.56    177849.56    414.57641    414.57641 
    8000   -7031.0166   -7031.0166   -7201.8595   -7201.8595    330.50725    330.50725    178581.67    178581.67    -252.1631    -252.1631 
Loop time of 195.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.256 hours/ns, 5.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.13     | 194.13     | 194.13     |   0.0 | 99.39
Neigh   | 0.34013    | 0.34013    | 0.34013    |   0.0 |  0.17
Comm    | 0.11003    | 0.11003    | 0.11003    |   0.0 |  0.06
Output  | 0.00017537 | 0.00017537 | 0.00017537 |   0.0 |  0.00
Modify  | 0.65627    | 0.65627    | 0.65627    |   0.0 |  0.34
Other   |            | 0.09       |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3815.00 ave        3815 max        3815 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:      195238.0 ave      195238 max      195238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195238
Ave neighs/atom = 48.809500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.155022980794, Press = 1.49563085418385
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7031.0166   -7031.0166   -7201.8595   -7201.8595    330.50725    330.50725    178581.67    178581.67    -252.1631    -252.1631 
    9000   -7035.3788   -7035.3788   -7205.7774   -7205.7774    329.64755    329.64755    178001.51    178001.51    237.93503    237.93503 
Loop time of 195.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.183 hours/ns, 5.127 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.9      | 193.9      | 193.9      |   0.0 | 99.40
Neigh   | 0.30614    | 0.30614    | 0.30614    |   0.0 |  0.16
Comm    | 0.10993    | 0.10993    | 0.10993    |   0.0 |  0.06
Output  | 0.00017693 | 0.00017693 | 0.00017693 |   0.0 |  0.00
Modify  | 0.65531    | 0.65531    | 0.65531    |   0.0 |  0.34
Other   |            | 0.08999    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3814.00 ave        3814 max        3814 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:      195298.0 ave      195298 max      195298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195298
Ave neighs/atom = 48.824500
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.645504773411, Press = 0.965398931285617
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7035.3788   -7035.3788   -7205.7774   -7205.7774    329.64755    329.64755    178001.51    178001.51    237.93503    237.93503 
   10000   -7038.8093   -7038.8093   -7207.5587   -7207.5587    326.45709    326.45709    178324.17    178324.17   -90.520105   -90.520105 
Loop time of 195.408 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.280 hours/ns, 5.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.24     | 194.24     | 194.24     |   0.0 | 99.40
Neigh   | 0.30671    | 0.30671    | 0.30671    |   0.0 |  0.16
Comm    | 0.10961    | 0.10961    | 0.10961    |   0.0 |  0.06
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.65606    | 0.65606    | 0.65606    |   0.0 |  0.34
Other   |            | 0.09053    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3818.00 ave        3818 max        3818 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:      195686.0 ave      195686 max      195686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195686
Ave neighs/atom = 48.921500
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.534075998095, Press = 0.654652841684128
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7038.8093   -7038.8093   -7207.5587   -7207.5587    326.45709    326.45709    178324.17    178324.17   -90.520105   -90.520105 
   11000    -7031.645    -7031.645   -7202.8671   -7202.8671    331.24075    331.24075    178202.49    178202.49    120.92021    120.92021 
Loop time of 195.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.241 hours/ns, 5.121 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.07     | 194.07     | 194.07     |   0.0 | 99.39
Neigh   | 0.34079    | 0.34079    | 0.34079    |   0.0 |  0.17
Comm    | 0.11018    | 0.11018    | 0.11018    |   0.0 |  0.06
Output  | 0.00017565 | 0.00017565 | 0.00017565 |   0.0 |  0.00
Modify  | 0.65603    | 0.65603    | 0.65603    |   0.0 |  0.34
Other   |            | 0.09016    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3821.00 ave        3821 max        3821 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:      195472.0 ave      195472 max      195472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195472
Ave neighs/atom = 48.868000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.461945067229, Press = 1.30145884235213
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -7031.645    -7031.645   -7202.8671   -7202.8671    331.24075    331.24075    178202.49    178202.49    120.92021    120.92021 
   12000   -7035.3114   -7035.3114   -7206.9462   -7206.9462    332.03918    332.03918    178481.49    178481.49   -205.66065   -205.66065 
Loop time of 195.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.224 hours/ns, 5.123 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.01     | 194.01     | 194.01     |   0.0 | 99.39
Neigh   | 0.34049    | 0.34049    | 0.34049    |   0.0 |  0.17
Comm    | 0.11041    | 0.11041    | 0.11041    |   0.0 |  0.06
Output  | 0.00017242 | 0.00017242 | 0.00017242 |   0.0 |  0.00
Modify  | 0.65597    | 0.65597    | 0.65597    |   0.0 |  0.34
Other   |            | 0.0898     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3815.00 ave        3815 max        3815 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:      195076.0 ave      195076 max      195076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195076
Ave neighs/atom = 48.769000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.221913072581, Press = -0.367874659310874
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7035.3114   -7035.3114   -7206.9462   -7206.9462    332.03918    332.03918    178481.49    178481.49   -205.66065   -205.66065 
   13000   -7034.0876   -7034.0876   -7205.9062   -7205.9062    332.39476    332.39476    178022.67    178022.67     276.1822     276.1822 
Loop time of 195.196 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.221 hours/ns, 5.123 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194        | 194        | 194        |   0.0 | 99.39
Neigh   | 0.34066    | 0.34066    | 0.34066    |   0.0 |  0.17
Comm    | 0.11159    | 0.11159    | 0.11159    |   0.0 |  0.06
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.65552    | 0.65552    | 0.65552    |   0.0 |  0.34
Other   |            | 0.08977    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3819.00 ave        3819 max        3819 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:      195834.0 ave      195834 max      195834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195834
Ave neighs/atom = 48.958500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.358489286608, Press = 1.7586699785959
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7034.0876   -7034.0876   -7205.9062   -7205.9062    332.39476    332.39476    178022.67    178022.67     276.1822     276.1822 
   14000    -7029.674    -7029.674   -7203.8056   -7203.8056    336.86946    336.86946    178511.17    178511.17   -178.38029   -178.38029 
Loop time of 195.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.293 hours/ns, 5.116 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.26     | 194.26     | 194.26     |   0.0 | 99.39
Neigh   | 0.34056    | 0.34056    | 0.34056    |   0.0 |  0.17
Comm    | 0.11102    | 0.11102    | 0.11102    |   0.0 |  0.06
Output  | 0.0002184  | 0.0002184  | 0.0002184  |   0.0 |  0.00
Modify  | 0.65683    | 0.65683    | 0.65683    |   0.0 |  0.34
Other   |            | 0.08944    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3818.00 ave        3818 max        3818 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:      194740.0 ave      194740 max      194740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194740
Ave neighs/atom = 48.685000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.403016263597, Press = -1.97571631206882
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -7029.674    -7029.674   -7203.8056   -7203.8056    336.86946    336.86946    178511.17    178511.17   -178.38029   -178.38029 
   15000   -7034.2763   -7034.2763   -7205.7294   -7205.7294     331.6878     331.6878    178291.03    178291.03  -0.70983602  -0.70983602 
Loop time of 197.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.780 hours/ns, 5.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.03     | 196.03     | 196.03     |   0.0 | 99.40
Neigh   | 0.30814    | 0.30814    | 0.30814    |   0.0 |  0.16
Comm    | 0.11175    | 0.11175    | 0.11175    |   0.0 |  0.06
Output  | 0.00021282 | 0.00021282 | 0.00021282 |   0.0 |  0.00
Modify  | 0.6643     | 0.6643     | 0.6643     |   0.0 |  0.34
Other   |            | 0.08993    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3819.00 ave        3819 max        3819 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:      195704.0 ave      195704 max      195704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195704
Ave neighs/atom = 48.926000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.307251490051, Press = 1.50647197486869
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -7034.2763   -7034.2763   -7205.7294   -7205.7294     331.6878     331.6878    178291.03    178291.03  -0.70983602  -0.70983602 
   16000    -7032.214    -7032.214   -7204.8689   -7204.8689    334.01279    334.01279    178290.89    178290.89    5.0952641    5.0952641 
Loop time of 222.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.924 hours/ns, 4.486 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    | 221.57     | 221.57     | 221.57     |   0.0 | 99.39
Neigh   | 0.32797    | 0.32797    | 0.32797    |   0.0 |  0.15
Comm    | 0.12499    | 0.12499    | 0.12499    |   0.0 |  0.06
Output  | 0.00017646 | 0.00017646 | 0.00017646 |   0.0 |  0.00
Modify  | 0.80185    | 0.80185    | 0.80185    |   0.0 |  0.36
Other   |            | 0.09708    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3820.00 ave        3820 max        3820 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:      194740.0 ave      194740 max      194740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194740
Ave neighs/atom = 48.685000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.29738593087, Press = -0.47404265793409
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -7032.214    -7032.214   -7204.8689   -7204.8689    334.01279    334.01279    178290.89    178290.89    5.0952641    5.0952641 
   17000   -7032.0404   -7032.0404   -7203.0357   -7203.0357    330.80191    330.80191       178404       178404   -74.570233   -74.570233 
Loop time of 208.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 58.016 hours/ns, 4.788 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    | 207.56     | 207.56     | 207.56     |   0.0 | 99.38
Neigh   | 0.35308    | 0.35308    | 0.35308    |   0.0 |  0.17
Comm    | 0.1179     | 0.1179     | 0.1179     |   0.0 |  0.06
Output  | 0.00022096 | 0.00022096 | 0.00022096 |   0.0 |  0.00
Modify  | 0.73038    | 0.73038    | 0.73038    |   0.0 |  0.35
Other   |            | 0.09364    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3816.00 ave        3816 max        3816 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:      195320.0 ave      195320 max      195320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195320
Ave neighs/atom = 48.830000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.420868076779, Press = 0.704891605838408
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7032.0404   -7032.0404   -7203.0357   -7203.0357    330.80191    330.80191       178404       178404   -74.570233   -74.570233 
   18000   -7024.1856   -7024.1856   -7199.7566   -7199.7566    339.65416    339.65416    178489.85    178489.85    -67.21659    -67.21659 
Loop time of 195.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.352 hours/ns, 5.111 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.47     | 194.47     | 194.47     |   0.0 | 99.39
Neigh   | 0.34183    | 0.34183    | 0.34183    |   0.0 |  0.17
Comm    | 0.1118     | 0.1118     | 0.1118     |   0.0 |  0.06
Output  | 0.00017708 | 0.00017708 | 0.00017708 |   0.0 |  0.00
Modify  | 0.65931    | 0.65931    | 0.65931    |   0.0 |  0.34
Other   |            | 0.08989    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3817.00 ave        3817 max        3817 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:      194846.0 ave      194846 max      194846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194846
Ave neighs/atom = 48.711500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.513166199979, Press = -0.379462033205319
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7024.1856   -7024.1856   -7199.7566   -7199.7566    339.65416    339.65416    178489.85    178489.85    -67.21659    -67.21659 
   19000   -7032.3867   -7032.3867    -7203.038    -7203.038    330.13646    330.13646       178227       178227    111.14408    111.14408 
Loop time of 195.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.382 hours/ns, 5.108 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.57     | 194.57     | 194.57     |   0.0 | 99.38
Neigh   | 0.34306    | 0.34306    | 0.34306    |   0.0 |  0.18
Comm    | 0.11166    | 0.11166    | 0.11166    |   0.0 |  0.06
Output  | 0.00022603 | 0.00022603 | 0.00022603 |   0.0 |  0.00
Modify  | 0.66144    | 0.66144    | 0.66144    |   0.0 |  0.34
Other   |            | 0.08992    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3814.00 ave        3814 max        3814 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:      195584.0 ave      195584 max      195584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195584
Ave neighs/atom = 48.896000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.615039832809, Press = 0.296115009109022
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7032.3867   -7032.3867    -7203.038    -7203.038    330.13646    330.13646       178227       178227    111.14408    111.14408 
   20000   -7028.8824   -7028.8824   -7202.6481   -7202.6481    336.16141    336.16141     178403.4     178403.4   -44.267043   -44.267043 
Loop time of 195.354 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.265 hours/ns, 5.119 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.19     | 194.19     | 194.19     |   0.0 | 99.40
Neigh   | 0.3065     | 0.3065     | 0.3065     |   0.0 |  0.16
Comm    | 0.11042    | 0.11042    | 0.11042    |   0.0 |  0.06
Output  | 0.00017825 | 0.00017825 | 0.00017825 |   0.0 |  0.00
Modify  | 0.65923    | 0.65923    | 0.65923    |   0.0 |  0.34
Other   |            | 0.09102    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3816.00 ave        3816 max        3816 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:      195024.0 ave      195024 max      195024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195024
Ave neighs/atom = 48.756000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.568520604088, Press = -0.338092423767266
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7028.8824   -7028.8824   -7202.6481   -7202.6481    336.16141    336.16141     178403.4     178403.4   -44.267043   -44.267043 
   21000    -7032.262    -7032.262   -7203.0181   -7203.0181     330.3394     330.3394    178340.68    178340.68   -10.304893   -10.304893 
Loop time of 196.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.484 hours/ns, 5.098 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.97     | 194.97     | 194.97     |   0.0 | 99.40
Neigh   | 0.30772    | 0.30772    | 0.30772    |   0.0 |  0.16
Comm    | 0.11206    | 0.11206    | 0.11206    |   0.0 |  0.06
Output  | 0.00017741 | 0.00017741 | 0.00017741 |   0.0 |  0.00
Modify  | 0.65981    | 0.65981    | 0.65981    |   0.0 |  0.34
Other   |            | 0.08882    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3820.00 ave        3820 max        3820 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:      195258.0 ave      195258 max      195258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195258
Ave neighs/atom = 48.814500
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.732689404782, Press = 0.190825393082134
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -7032.262    -7032.262   -7203.0181   -7203.0181     330.3394     330.3394    178340.68    178340.68   -10.304893   -10.304893 
   22000   -7032.6628   -7032.6628   -7204.0381   -7204.0381    331.53721    331.53721    178168.02    178168.02    126.78508    126.78508 
Loop time of 203.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.596 hours/ns, 4.908 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.51     | 202.51     | 202.51     |   0.0 | 99.40
Neigh   | 0.31348    | 0.31348    | 0.31348    |   0.0 |  0.15
Comm    | 0.11877    | 0.11877    | 0.11877    |   0.0 |  0.06
Output  | 0.00023638 | 0.00023638 | 0.00023638 |   0.0 |  0.00
Modify  | 0.70469    | 0.70469    | 0.70469    |   0.0 |  0.35
Other   |            | 0.09251    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3814.00 ave        3814 max        3814 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:      195000.0 ave      195000 max      195000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195000
Ave neighs/atom = 48.750000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.818194864945, Press = 0.00350079818968222
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7032.6628   -7032.6628   -7204.0381   -7204.0381    331.53721    331.53721    178168.02    178168.02    126.78508    126.78508 
   23000   -7030.5417   -7030.5417     -7200.95     -7200.95    329.66649    329.66649    178446.99    178446.99   -99.957529   -99.957529 
Loop time of 203.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.545 hours/ns, 4.912 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.3      | 202.3      | 202.3      |   0.0 | 99.38
Neigh   | 0.34596    | 0.34596    | 0.34596    |   0.0 |  0.17
Comm    | 0.11628    | 0.11628    | 0.11628    |   0.0 |  0.06
Output  | 0.00018106 | 0.00018106 | 0.00018106 |   0.0 |  0.00
Modify  | 0.70549    | 0.70549    | 0.70549    |   0.0 |  0.35
Other   |            | 0.09237    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3818.00 ave        3818 max        3818 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:      194962.0 ave      194962 max      194962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 194962
Ave neighs/atom = 48.740500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.814777948812, Press = -0.0393221962778141
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7030.5417   -7030.5417     -7200.95     -7200.95    329.66649    329.66649    178446.99    178446.99   -99.957529   -99.957529 
   24000   -7033.5025   -7033.5025   -7203.5769   -7203.5769    329.02051    329.02051    178078.19    178078.19    231.40135    231.40135 
Loop time of 207.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.622 hours/ns, 4.821 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    | 206.19     | 206.19     | 206.19     |   0.0 | 99.40
Neigh   | 0.31897    | 0.31897    | 0.31897    |   0.0 |  0.15
Comm    | 0.11697    | 0.11697    | 0.11697    |   0.0 |  0.06
Output  | 0.00022116 | 0.00022116 | 0.00022116 |   0.0 |  0.00
Modify  | 0.72523    | 0.72523    | 0.72523    |   0.0 |  0.35
Other   |            | 0.09318    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3822.00 ave        3822 max        3822 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:      195384.0 ave      195384 max      195384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195384
Ave neighs/atom = 48.846000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.743431628004, Press = 0.858829131931671
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7033.5025   -7033.5025   -7203.5769   -7203.5769    329.02051    329.02051    178078.19    178078.19    231.40135    231.40135 
   25000   -7032.0962   -7032.0962   -7202.6557   -7202.6557    329.95876    329.95876     178472.4     178472.4   -117.13011   -117.13011 
Loop time of 196.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.514 hours/ns, 5.096 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.08     | 195.08     | 195.08     |   0.0 | 99.40
Neigh   | 0.30792    | 0.30792    | 0.30792    |   0.0 |  0.16
Comm    | 0.1141     | 0.1141     | 0.1141     |   0.0 |  0.06
Output  | 0.0001803  | 0.0001803  | 0.0001803  |   0.0 |  0.00
Modify  | 0.66447    | 0.66447    | 0.66447    |   0.0 |  0.34
Other   |            | 0.08838    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3822.00 ave        3822 max        3822 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:      195084.0 ave      195084 max      195084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195084
Ave neighs/atom = 48.771000
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.870381421469, Press = -0.581108154825385
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -7032.0962   -7032.0962   -7202.6557   -7202.6557    329.95876    329.95876     178472.4     178472.4   -117.13011   -117.13011 
   26000   -7027.4912   -7027.4912   -7200.2971   -7200.2971    334.30487    334.30487    178328.12    178328.12    51.954708    51.954708 
Loop time of 209.127 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.091 hours/ns, 4.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.83     | 207.83     | 207.83     |   0.0 | 99.38
Neigh   | 0.35262    | 0.35262    | 0.35262    |   0.0 |  0.17
Comm    | 0.11924    | 0.11924    | 0.11924    |   0.0 |  0.06
Output  | 0.00023877 | 0.00023877 | 0.00023877 |   0.0 |  0.00
Modify  | 0.73343    | 0.73343    | 0.73343    |   0.0 |  0.35
Other   |            | 0.09375    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3816.00 ave        3816 max        3816 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:      195046.0 ave      195046 max      195046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195046
Ave neighs/atom = 48.761500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.915188123483, Press = 0.631624076723267
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7027.4912   -7027.4912   -7200.2971   -7200.2971    334.30487    334.30487    178328.12    178328.12    51.954708    51.954708 
   27000   -7033.3937   -7033.3937   -7205.3221   -7205.3221    332.60701    332.60701    178180.13    178180.13    111.96904    111.96904 
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
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.82     | 203.82     | 203.82     |   0.0 | 99.38
Neigh   | 0.34921    | 0.34921    | 0.34921    |   0.0 |  0.17
Comm    | 0.11711    | 0.11711    | 0.11711    |   0.0 |  0.06
Output  | 0.00017644 | 0.00017644 | 0.00017644 |   0.0 |  0.00
Modify  | 0.70765    | 0.70765    | 0.70765    |   0.0 |  0.35
Other   |            | 0.09198    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3813.00 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      195384.0 ave      195384 max      195384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195384
Ave neighs/atom = 48.846000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.00785626548, Press = -0.298581017148696
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7033.3937   -7033.3937   -7205.3221   -7205.3221    332.60701    332.60701    178180.13    178180.13    111.96904    111.96904 
   28000   -7029.0393   -7029.0393   -7201.3968   -7201.3968    333.43727    333.43727    178772.36    178772.36   -400.84196   -400.84196 
Loop time of 194.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.097 hours/ns, 5.135 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.55     | 193.55     | 193.55     |   0.0 | 99.39
Neigh   | 0.33969    | 0.33969    | 0.33969    |   0.0 |  0.17
Comm    | 0.11158    | 0.11158    | 0.11158    |   0.0 |  0.06
Output  | 0.00022007 | 0.00022007 | 0.00022007 |   0.0 |  0.00
Modify  | 0.6538     | 0.6538     | 0.6538     |   0.0 |  0.34
Other   |            | 0.08947    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3817.00 ave        3817 max        3817 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:      195084.0 ave      195084 max      195084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195084
Ave neighs/atom = 48.771000
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.056761422419, Press = 0.924957388041641
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7029.0393   -7029.0393   -7201.3968   -7201.3968    333.43727    333.43727    178772.36    178772.36   -400.84196   -400.84196 
   29000    -7032.864    -7032.864   -7205.9186   -7205.9186    334.78583    334.78583    177945.29    177945.29    306.59586    306.59586 
Loop time of 194.55 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.042 hours/ns, 5.140 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.36     | 193.36     | 193.36     |   0.0 | 99.39
Neigh   | 0.33998    | 0.33998    | 0.33998    |   0.0 |  0.17
Comm    | 0.1107     | 0.1107     | 0.1107     |   0.0 |  0.06
Output  | 0.00017607 | 0.00017607 | 0.00017607 |   0.0 |  0.00
Modify  | 0.65358    | 0.65358    | 0.65358    |   0.0 |  0.34
Other   |            | 0.08972    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3820.00 ave        3820 max        3820 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:      195222.0 ave      195222 max      195222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195222
Ave neighs/atom = 48.805500
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.090334535324, Press = -0.387949291995675
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -7032.864    -7032.864   -7205.9186   -7205.9186    334.78583    334.78583    177945.29    177945.29    306.59586    306.59586 
   30000   -7035.4422   -7035.4422   -7206.3016   -7206.3016    330.53914    330.53914    178403.97    178403.97     -134.236     -134.236 
Loop time of 194.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.052 hours/ns, 5.139 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.43     | 193.43     | 193.43     |   0.0 | 99.40
Neigh   | 0.30591    | 0.30591    | 0.30591    |   0.0 |  0.16
Comm    | 0.11039    | 0.11039    | 0.11039    |   0.0 |  0.06
Output  | 0.00017561 | 0.00017561 | 0.00017561 |   0.0 |  0.00
Modify  | 0.65402    | 0.65402    | 0.65402    |   0.0 |  0.34
Other   |            | 0.08914    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3819.00 ave        3819 max        3819 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:      195450.0 ave      195450 max      195450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195450
Ave neighs/atom = 48.862500
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.096367684409, Press = 0.220099371704055
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7035.4422   -7035.4422   -7206.3016   -7206.3016    330.53914    330.53914    178403.97    178403.97     -134.236     -134.236 
   31000    -7032.541    -7032.541   -7205.5329   -7205.5329    334.66455    334.66455    178124.47    178124.47    159.62399    159.62399 
Loop time of 194.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.066 hours/ns, 5.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.48     | 193.48     | 193.48     |   0.0 | 99.40
Neigh   | 0.30566    | 0.30566    | 0.30566    |   0.0 |  0.16
Comm    | 0.11061    | 0.11061    | 0.11061    |   0.0 |  0.06
Output  | 0.00017672 | 0.00017672 | 0.00017672 |   0.0 |  0.00
Modify  | 0.65383    | 0.65383    | 0.65383    |   0.0 |  0.34
Other   |            | 0.08993    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3818.00 ave        3818 max        3818 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:      195288.0 ave      195288 max      195288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0