# 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.302343912422657*${_u_distance}
variable latticeconst_converted equal 3.302343912422657*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30234391242266
Lattice spacing in x,y,z = 3.3023439 3.3023439 3.3023439
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 (33.023439 33.023439 33.023439)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.023439 33.023439 33.023439)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_HuangLiuDuan_2021_HfNbTaTiZr__MO_893505888031_001
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36013.6300215875 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_893505888031_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -16102.65    -16102.65   -16183.565   -16183.565       313.15       313.15     36013.63     36013.63    2399.8456    2399.8456 
    1000   -16017.796   -16017.796   -16089.984   -16089.984    279.37505    279.37505    36101.773    36101.773    6283.5672    6283.5672 
Loop time of 563.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.153 ns/day, 156.592 hours/ns, 1.774 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    | 563.16     | 563.16     | 563.16     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1051     | 0.1051     | 0.1051     |   0.0 |  0.02
Output  | 0.0001958  | 0.0001958  | 0.0001958  |   0.0 |  0.00
Modify  | 0.39842    | 0.39842    | 0.39842    |   0.0 |  0.07
Other   |            | 0.06395    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16017.796   -16017.796   -16089.984   -16089.984    279.37505    279.37505    36101.773    36101.773    6283.5672    6283.5672 
    2000   -16017.178   -16017.178   -16101.156   -16101.156    325.00543    325.00543    36219.053    36219.053   -1061.7741   -1061.7741 
Loop time of 532.203 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 147.834 hours/ns, 1.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 531.71     | 531.71     | 531.71     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094484   | 0.094484   | 0.094484   |   0.0 |  0.02
Output  | 0.00019272 | 0.00019272 | 0.00019272 |   0.0 |  0.00
Modify  | 0.33499    | 0.33499    | 0.33499    |   0.0 |  0.06
Other   |            | 0.05925    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128964.0 ave      128964 max      128964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128964
Ave neighs/atom = 64.482000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -16017.178   -16017.178   -16101.156   -16101.156    325.00543    325.00543    36219.053    36219.053   -1061.7741   -1061.7741 
    3000   -16020.831   -16020.831   -16103.855   -16103.855    321.31119    321.31119     36172.21     36172.21    1218.2757    1218.2757 
Loop time of 546.575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.158 ns/day, 151.826 hours/ns, 1.830 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    | 546.06     | 546.06     | 546.06     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098189   | 0.098189   | 0.098189   |   0.0 |  0.02
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.35394    | 0.35394    | 0.35394    |   0.0 |  0.06
Other   |            | 0.06015    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128568.0 ave      128568 max      128568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128568
Ave neighs/atom = 64.284000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -16020.831   -16020.831   -16103.855   -16103.855    321.31119    321.31119     36172.21     36172.21    1218.2757    1218.2757 
    4000   -16021.227   -16021.227   -16097.726   -16097.726    296.06159    296.06159    36179.087    36179.087     1271.725     1271.725 
Loop time of 584.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.493 hours/ns, 1.709 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    | 584.4      | 584.4      | 584.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10573    | 0.10573    | 0.10573    |   0.0 |  0.02
Output  | 0.00023498 | 0.00023498 | 0.00023498 |   0.0 |  0.00
Modify  | 0.40081    | 0.40081    | 0.40081    |   0.0 |  0.07
Other   |            | 0.06448    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128582.0 ave      128582 max      128582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128582
Ave neighs/atom = 64.291000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -16021.227   -16021.227   -16097.726   -16097.726    296.06159    296.06159    36179.087    36179.087     1271.725     1271.725 
    5000   -16020.117   -16020.117   -16096.988   -16096.988    297.49726    297.49726    36221.832    36221.832   -1218.2761   -1218.2761 
Loop time of 595.291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.359 hours/ns, 1.680 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    | 594.7      | 594.7      | 594.7      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10782    | 0.10782    | 0.10782    |   0.0 |  0.02
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.41519    | 0.41519    | 0.41519    |   0.0 |  0.07
Other   |            | 0.06588    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128912.0 ave      128912 max      128912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128912
Ave neighs/atom = 64.456000
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 = 318.139534823164, Press = 85.5325965744248
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16020.117   -16020.117   -16096.988   -16096.988    297.49726    297.49726    36221.832    36221.832   -1218.2761   -1218.2761 
    6000   -16020.437   -16020.437   -16098.253   -16098.253    301.15484    301.15484    36242.802    36242.802    -2124.476    -2124.476 
Loop time of 585.898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 162.749 hours/ns, 1.707 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    | 585.31     | 585.31     | 585.31     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10592    | 0.10592    | 0.10592    |   0.0 |  0.02
Output  | 0.00015624 | 0.00015624 | 0.00015624 |   0.0 |  0.00
Modify  | 0.41981    | 0.41981    | 0.41981    |   0.0 |  0.07
Other   |            | 0.06374    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128706.0 ave      128706 max      128706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128706
Ave neighs/atom = 64.353000
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 = 314.232307933628, Press = -5.57890162960846
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16020.437   -16020.437   -16098.253   -16098.253    301.15484    301.15484    36242.802    36242.802    -2124.476    -2124.476 
    7000   -16021.327   -16021.327   -16097.131   -16097.131    293.36944    293.36944    36202.415    36202.415    93.937812    93.937812 
Loop time of 532.223 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 147.840 hours/ns, 1.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 531.72     | 531.72     | 531.72     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09543    | 0.09543    | 0.09543    |   0.0 |  0.02
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.35264    | 0.35264    | 0.35264    |   0.0 |  0.07
Other   |            | 0.05832    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128660.0 ave      128660 max      128660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128660
Ave neighs/atom = 64.330000
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 = 314.293413642174, Press = 45.3228779392675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -16021.327   -16021.327   -16097.131   -16097.131    293.36944    293.36944    36202.415    36202.415    93.937812    93.937812 
    8000   -16019.513   -16019.513   -16104.101   -16104.101    327.36176    327.36176    36224.619    36224.619   -1591.4081   -1591.4081 
Loop time of 582.149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 161.708 hours/ns, 1.718 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    | 581.57     | 581.57     | 581.57     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10434    | 0.10434    | 0.10434    |   0.0 |  0.02
Output  | 0.00015538 | 0.00015538 | 0.00015538 |   0.0 |  0.00
Modify  | 0.41573    | 0.41573    | 0.41573    |   0.0 |  0.07
Other   |            | 0.0635     |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128644.0 ave      128644 max      128644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128644
Ave neighs/atom = 64.322000
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 = 314.116081535723, Press = 11.7204538937824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16019.513   -16019.513   -16104.101   -16104.101    327.36176    327.36176    36224.619    36224.619   -1591.4081   -1591.4081 
    9000   -16021.964   -16021.964   -16098.699   -16098.699    296.96879    296.96879    36186.203    36186.203    849.63336    849.63336 
Loop time of 602.171 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.270 hours/ns, 1.661 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    | 601.55     | 601.55     | 601.55     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.02
Output  | 0.00025438 | 0.00025438 | 0.00025438 |   0.0 |  0.00
Modify  | 0.44126    | 0.44126    | 0.44126    |   0.0 |  0.07
Other   |            | 0.06627    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128482.0 ave      128482 max      128482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128482
Ave neighs/atom = 64.241000
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 = 313.880950110846, Press = 19.2380697678116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -16021.964   -16021.964   -16098.699   -16098.699    296.96879    296.96879    36186.203    36186.203    849.63336    849.63336 
   10000   -16018.932   -16018.932   -16102.734   -16102.734    324.32519    324.32519    36213.366    36213.366   -789.13868   -789.13868 
Loop time of 602.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.346 hours/ns, 1.660 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    | 601.83     | 601.83     | 601.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10893    | 0.10893    | 0.10893    |   0.0 |  0.02
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.44193    | 0.44193    | 0.44193    |   0.0 |  0.07
Other   |            | 0.06635    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128622.0 ave      128622 max      128622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128622
Ave neighs/atom = 64.311000
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 = 313.808557612226, Press = 6.92622452981174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -16018.932   -16018.932   -16102.734   -16102.734    324.32519    324.32519    36213.366    36213.366   -789.13868   -789.13868 
   11000   -16016.355   -16016.355   -16098.749   -16098.749    318.87293    318.87293    36189.815    36189.815    923.94762    923.94762 
Loop time of 562.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.154 ns/day, 156.255 hours/ns, 1.778 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    | 561.97     | 561.97     | 561.97     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10062    | 0.10062    | 0.10062    |   0.0 |  0.02
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.38825    | 0.38825    | 0.38825    |   0.0 |  0.07
Other   |            | 0.06146    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128514.0 ave      128514 max      128514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128514
Ave neighs/atom = 64.257000
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 = 314.077276521368, Press = 0.389627778234395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16016.355   -16016.355   -16098.749   -16098.749    318.87293    318.87293    36189.815    36189.815    923.94762    923.94762 
   12000   -16019.886   -16019.886   -16098.601   -16098.601    304.63814    304.63814    36157.917    36157.917    2368.7917    2368.7917 
Loop time of 594.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.217 hours/ns, 1.681 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    | 594.18     | 594.18     | 594.18     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10731    | 0.10731    | 0.10731    |   0.0 |  0.02
Output  | 0.00015693 | 0.00015693 | 0.00015693 |   0.0 |  0.00
Modify  | 0.42768    | 0.42768    | 0.42768    |   0.0 |  0.07
Other   |            | 0.0647     |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128684.0 ave      128684 max      128684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128684
Ave neighs/atom = 64.342000
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 = 313.960883343491, Press = 9.65041541809799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16019.886   -16019.886   -16098.601   -16098.601    304.63814    304.63814    36157.917    36157.917    2368.7917    2368.7917 
   13000   -16018.491   -16018.491   -16099.776   -16099.776    314.57977    314.57977    36193.366    36193.366     588.2221     588.2221 
Loop time of 599.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.462 hours/ns, 1.669 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    | 598.66     | 598.66     | 598.66     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10631    | 0.10631    | 0.10631    |   0.0 |  0.02
Output  | 0.00019091 | 0.00019091 | 0.00019091 |   0.0 |  0.00
Modify  | 0.43591    | 0.43591    | 0.43591    |   0.0 |  0.07
Other   |            | 0.06441    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128714.0 ave      128714 max      128714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128714
Ave neighs/atom = 64.357000
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 = 313.793478443491, Press = 4.11262587548734
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16018.491   -16018.491   -16099.776   -16099.776    314.57977    314.57977    36193.366    36193.366     588.2221     588.2221 
   14000   -16022.222   -16022.222   -16100.717   -16100.717    303.78645    303.78645    36190.256    36190.256    510.81688    510.81688 
Loop time of 558.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.155 ns/day, 155.043 hours/ns, 1.792 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    | 557.61     | 557.61     | 557.61     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099125   | 0.099125   | 0.099125   |   0.0 |  0.02
Output  | 0.00019222 | 0.00019222 | 0.00019222 |   0.0 |  0.00
Modify  | 0.38374    | 0.38374    | 0.38374    |   0.0 |  0.07
Other   |            | 0.06024    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128654.0 ave      128654 max      128654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128654
Ave neighs/atom = 64.327000
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 = 313.869487989522, Press = 2.82628206396445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -16022.222   -16022.222   -16100.717   -16100.717    303.78645    303.78645    36190.256    36190.256    510.81688    510.81688 
   15000   -16018.585   -16018.585   -16100.948   -16100.948    318.75176    318.75176    36158.023    36158.023    2287.2166    2287.2166 
Loop time of 572.308 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 158.975 hours/ns, 1.747 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    | 571.74     | 571.74     | 571.74     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10126    | 0.10126    | 0.10126    |   0.0 |  0.02
Output  | 0.00019227 | 0.00019227 | 0.00019227 |   0.0 |  0.00
Modify  | 0.40191    | 0.40191    | 0.40191    |   0.0 |  0.07
Other   |            | 0.06162    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128594.0 ave      128594 max      128594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128594
Ave neighs/atom = 64.297000
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 = 313.622047050629, Press = 0.174332412329479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -16018.585   -16018.585   -16100.948   -16100.948    318.75176    318.75176    36158.023    36158.023    2287.2166    2287.2166 
   16000   -16021.477   -16021.477   -16102.618   -16102.618    314.02329    314.02329      36224.5      36224.5   -1370.8437   -1370.8437 
Loop time of 599.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.649 hours/ns, 1.667 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    | 599.33     | 599.33     | 599.33     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10638    | 0.10638    | 0.10638    |   0.0 |  0.02
Output  | 0.0001572  | 0.0001572  | 0.0001572  |   0.0 |  0.00
Modify  | 0.43668    | 0.43668    | 0.43668    |   0.0 |  0.07
Other   |            | 0.0648     |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128652.0 ave      128652 max      128652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128652
Ave neighs/atom = 64.326000
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 = 313.454631582284, Press = -1.22122238677044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -16021.477   -16021.477   -16102.618   -16102.618    314.02329    314.02329      36224.5      36224.5   -1370.8437   -1370.8437 
   17000   -16021.359   -16021.359   -16100.887   -16100.887    307.78034    307.78034    36214.709    36214.709   -809.78234   -809.78234 
Loop time of 607.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.835 hours/ns, 1.645 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    | 607.19     | 607.19     | 607.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10758    | 0.10758    | 0.10758    |   0.0 |  0.02
Output  | 0.00015725 | 0.00015725 | 0.00015725 |   0.0 |  0.00
Modify  | 0.44215    | 0.44215    | 0.44215    |   0.0 |  0.07
Other   |            | 0.06476    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128592.0 ave      128592 max      128592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128592
Ave neighs/atom = 64.296000
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 = 313.483999676292, Press = 6.17883095162647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16021.359   -16021.359   -16100.887   -16100.887    307.78034    307.78034    36214.709    36214.709   -809.78234   -809.78234 
   18000   -16021.056   -16021.056   -16097.663   -16097.663    296.48036    296.48036    36163.488    36163.488     1961.236     1961.236 
Loop time of 602.069 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.241 hours/ns, 1.661 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    | 601.45     | 601.45     | 601.45     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.02
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.44075    | 0.44075    | 0.44075    |   0.0 |  0.07
Other   |            | 0.06554    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128582.0 ave      128582 max      128582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128582
Ave neighs/atom = 64.291000
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 = 313.507611503017, Press = 2.97630646425067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16021.056   -16021.056   -16097.663   -16097.663    296.48036    296.48036    36163.488    36163.488     1961.236     1961.236 
   19000   -16017.412   -16017.412   -16095.932   -16095.932    303.88328    303.88328    36180.897    36180.897    1324.9776    1324.9776 
Loop time of 594.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.017 hours/ns, 1.683 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    | 593.46     | 593.46     | 593.46     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10454    | 0.10454    | 0.10454    |   0.0 |  0.02
Output  | 0.00021151 | 0.00021151 | 0.00021151 |   0.0 |  0.00
Modify  | 0.4314     | 0.4314     | 0.4314     |   0.0 |  0.07
Other   |            | 0.06359    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128826.0 ave      128826 max      128826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128826
Ave neighs/atom = 64.413000
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 = 313.424696414676, Press = -1.26488568034313
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -16017.412   -16017.412   -16095.932   -16095.932    303.88328    303.88328    36180.897    36180.897    1324.9776    1324.9776 
   20000   -16019.485   -16019.485   -16098.572   -16098.572    306.07324    306.07324    36201.185    36201.185   -4.2451562   -4.2451562 
Loop time of 611.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.141 ns/day, 169.775 hours/ns, 1.636 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    | 610.58     | 610.58     | 610.58     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10531    | 0.10531    | 0.10531    |   0.0 |  0.02
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.43839    | 0.43839    | 0.43839    |   0.0 |  0.07
Other   |            | 0.0646     |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128804.0 ave      128804 max      128804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128804
Ave neighs/atom = 64.402000
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 = 313.622492524959, Press = 1.03885544355195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16019.485   -16019.485   -16098.572   -16098.572    306.07324    306.07324    36201.185    36201.185   -4.2451562   -4.2451562 
   21000   -16021.351   -16021.351   -16100.007   -16100.007    304.40623    304.40623    36203.463    36203.463   -151.66608   -151.66608 
Loop time of 590.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 163.951 hours/ns, 1.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 589.63     | 589.63     | 589.63     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10379    | 0.10379    | 0.10379    |   0.0 |  0.02
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.42586    | 0.42586    | 0.42586    |   0.0 |  0.07
Other   |            | 0.06335    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128764.0 ave      128764 max      128764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128764
Ave neighs/atom = 64.382000
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 = 313.647575734129, Press = -0.00706068187502473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16021.351   -16021.351   -16100.007   -16100.007    304.40623    304.40623    36203.463    36203.463   -151.66608   -151.66608 
   22000    -16015.78    -16015.78   -16097.098   -16097.098    314.70759    314.70759    36227.763    36227.763   -1190.0745   -1190.0745 
Loop time of 606.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.475 hours/ns, 1.649 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    | 605.9      | 605.9      | 605.9      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1068     | 0.1068     | 0.1068     |   0.0 |  0.02
Output  | 0.00019767 | 0.00019767 | 0.00019767 |   0.0 |  0.00
Modify  | 0.4436     | 0.4436     | 0.4436     |   0.0 |  0.07
Other   |            | 0.06412    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128668.0 ave      128668 max      128668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128668
Ave neighs/atom = 64.334000
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 = 313.659936617088, Press = 0.0358164280485067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -16015.78    -16015.78   -16097.098   -16097.098    314.70759    314.70759    36227.763    36227.763   -1190.0745   -1190.0745 
   23000   -16016.982   -16016.982   -16098.139   -16098.139    314.08642    314.08642    36256.259    36256.259    -2793.445    -2793.445 
Loop time of 584.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.260 hours/ns, 1.712 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    | 583.55     | 583.55     | 583.55     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10489    | 0.10489    | 0.10489    |   0.0 |  0.02
Output  | 0.00015772 | 0.00015772 | 0.00015772 |   0.0 |  0.00
Modify  | 0.41898    | 0.41898    | 0.41898    |   0.0 |  0.07
Other   |            | 0.06305    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128702.0 ave      128702 max      128702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128702
Ave neighs/atom = 64.351000
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 = 313.527794261993, Press = 1.06268417812028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -16016.982   -16016.982   -16098.139   -16098.139    314.08642    314.08642    36256.259    36256.259    -2793.445    -2793.445 
   24000   -16020.683   -16020.683    -16101.78    -16101.78    313.85101    313.85101    36197.848    36197.848    47.730342    47.730342 
Loop time of 610.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 169.527 hours/ns, 1.639 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    | 609.68     | 609.68     | 609.68     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10694    | 0.10694    | 0.10694    |   0.0 |  0.02
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.44987    | 0.44987    | 0.44987    |   0.0 |  0.07
Other   |            | 0.06537    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128602.0 ave      128602 max      128602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128602
Ave neighs/atom = 64.301000
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 = 313.48302147274, Press = 2.71223175275007
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16020.683   -16020.683    -16101.78    -16101.78    313.85101    313.85101    36197.848    36197.848    47.730342    47.730342 
   25000   -16021.959   -16021.959   -16102.451   -16102.451    311.51429    311.51429    36159.854    36159.854    2042.2171    2042.2171 
Loop time of 602.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.245 hours/ns, 1.661 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    | 601.47     | 601.47     | 601.47     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10846    | 0.10846    | 0.10846    |   0.0 |  0.02
Output  | 0.00022194 | 0.00022194 | 0.00022194 |   0.0 |  0.00
Modify  | 0.43881    | 0.43881    | 0.43881    |   0.0 |  0.07
Other   |            | 0.0652     |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128600.0 ave      128600 max      128600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128600
Ave neighs/atom = 64.300000
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 = 313.455873251786, Press = 2.59122849793371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16021.959   -16021.959   -16102.451   -16102.451    311.51429    311.51429    36159.854    36159.854    2042.2171    2042.2171 
   26000   -16019.066   -16019.066   -16100.383   -16100.383    314.70628    314.70628     36215.17     36215.17   -781.53669   -781.53669 
Loop time of 554.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.156 ns/day, 154.096 hours/ns, 1.803 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    | 554.2      | 554.2      | 554.2      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098662   | 0.098662   | 0.098662   |   0.0 |  0.02
Output  | 0.00015846 | 0.00015846 | 0.00015846 |   0.0 |  0.00
Modify  | 0.38162    | 0.38162    | 0.38162    |   0.0 |  0.07
Other   |            | 0.06076    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128612.0 ave      128612 max      128612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128612
Ave neighs/atom = 64.306000
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 = 313.452186432828, Press = -0.191658166024049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16019.066   -16019.066   -16100.383   -16100.383    314.70628    314.70628     36215.17     36215.17   -781.53669   -781.53669 
   27000   -16020.067   -16020.067   -16103.816   -16103.816    324.11509    324.11509    36196.711    36196.711    13.065635    13.065635 
Loop time of 531.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.163 ns/day, 147.683 hours/ns, 1.881 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    | 531.15     | 531.15     | 531.15     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09361    | 0.09361    | 0.09361    |   0.0 |  0.02
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.35203    | 0.35203    | 0.35203    |   0.0 |  0.07
Other   |            | 0.05814    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128584.0 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292000
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 = 313.505918839876, Press = 1.41910157607582
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -16020.067   -16020.067   -16103.816   -16103.816    324.11509    324.11509    36196.711    36196.711    13.065635    13.065635 
   28000    -16020.71    -16020.71   -16097.671   -16097.671    297.84601    297.84601    36213.691    36213.691   -650.96454   -650.96454 
Loop time of 541.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.160 ns/day, 150.463 hours/ns, 1.846 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    | 541.15     | 541.15     | 541.15     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096803   | 0.096803   | 0.096803   |   0.0 |  0.02
Output  | 0.00015849 | 0.00015849 | 0.00015849 |   0.0 |  0.00
Modify  | 0.36356    | 0.36356    | 0.36356    |   0.0 |  0.07
Other   |            | 0.06005    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128604.0 ave      128604 max      128604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128604
Ave neighs/atom = 64.302000
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 = 313.515968654065, Press = 1.48555222580213
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -16020.71    -16020.71   -16097.671   -16097.671    297.84601    297.84601    36213.691    36213.691   -650.96454   -650.96454 
   29000   -16015.993   -16015.993   -16096.283   -16096.283    310.72858    310.72858    36153.644    36153.644    2760.3321    2760.3321 
Loop time of 603.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.616 hours/ns, 1.657 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    | 602.8      | 602.8      | 602.8      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1094     | 0.1094     | 0.1094     |   0.0 |  0.02
Output  | 0.00015816 | 0.00015816 | 0.00015816 |   0.0 |  0.00
Modify  | 0.44125    | 0.44125    | 0.44125    |   0.0 |  0.07
Other   |            | 0.06565    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128674.0 ave      128674 max      128674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128674
Ave neighs/atom = 64.337000
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 = 313.599134210838, Press = 2.87363553011849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -16015.993   -16015.993   -16096.283   -16096.283    310.72858    310.72858    36153.644    36153.644    2760.3321    2760.3321 
   30000    -16018.57    -16018.57   -16102.528   -16102.528    324.92652    324.92652    36161.316    36161.316    1953.1652    1953.1652 
Loop time of 554.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.156 ns/day, 154.108 hours/ns, 1.802 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    | 554.26     | 554.26     | 554.26     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097066   | 0.097066   | 0.097066   |   0.0 |  0.02
Output  | 0.00019056 | 0.00019056 | 0.00019056 |   0.0 |  0.00
Modify  | 0.37551    | 0.37551    | 0.37551    |   0.0 |  0.07
Other   |            | 0.05977    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128734.0 ave      128734 max      128734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128734
Ave neighs/atom = 64.367000
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 = 313.558170834134, Press = -1.0595489903398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -16018.57    -16018.57   -16102.528   -16102.528    324.92652    324.92652    36161.316    36161.316    1953.1652    1953.1652 
   31000   -16020.501   -16020.501   -16100.363   -16100.363    309.07633    309.07633    36236.954    36236.954   -1967.4582   -1967.4582 
Loop time of 607.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.796 hours/ns, 1.646 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    | 607.04     | 607.04     | 607.04     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10808    | 0.10808    | 0.10808    |   0.0 |  0.02
Output  | 0.00015563 | 0.00015563 | 0.00015563 |   0.0 |  0.00
Modify  | 0.44997    | 0.44997    | 0.44997    |   0.0 |  0.07
Other   |            | 0.06567    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128602.0 ave      128602 max      128602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128602
Ave neighs/atom = 64.301000
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 = 313.524823639239, Press = 0.356558981641591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -16020.501   -16020.501   -16100.363   -16100.363    309.07633    309.07633    36236.954    36236.954   -1967.4582   -1967.4582 
   32000   -16019.352   -16019.352   -16099.676   -16099.676    310.86225    310.86225    36218.606    36218.606   -878.03867   -878.03867 
Loop time of 605.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.083 hours/ns, 1.653 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    | 604.49     | 604.49     | 604.49     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10607    | 0.10607    | 0.10607    |   0.0 |  0.02
Output  | 0.00020627 | 0.00020627 | 0.00020627 |   0.0 |  0.00
Modify  | 0.43759    | 0.43759    | 0.43759    |   0.0 |  0.07
Other   |            | 0.06449    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128574.0 ave      128574 max      128574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128574
Ave neighs/atom = 64.287000
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 = 313.474801311531, Press = 1.5897202219783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -16019.352   -16019.352   -16099.676   -16099.676    310.86225    310.86225    36218.606    36218.606   -878.03867   -878.03867 
   33000   -16021.046   -16021.046   -16101.637   -16101.637    311.89338    311.89338    36174.376    36174.376    1272.7534    1272.7534 
Loop time of 579.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 160.852 hours/ns, 1.727 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    | 578.48     | 578.48     | 578.48     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10381    | 0.10381    | 0.10381    |   0.0 |  0.02
Output  | 0.00015623 | 0.00015623 | 0.00015623 |   0.0 |  0.00
Modify  | 0.41395    | 0.41395    | 0.41395    |   0.0 |  0.07
Other   |            | 0.06364    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128628.0 ave      128628 max      128628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128628
Ave neighs/atom = 64.314000
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 = 313.446737179767, Press = 1.53837025710401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16021.046   -16021.046   -16101.637   -16101.637    311.89338    311.89338    36174.376    36174.376    1272.7534    1272.7534 
   34000   -16017.727   -16017.727    -16095.48    -16095.48    300.90994    300.90994    36195.174    36195.174    601.36586    601.36586 
Loop time of 572.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.151 ns/day, 159.136 hours/ns, 1.746 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    | 572.33     | 572.33     | 572.33     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10183    | 0.10183    | 0.10183    |   0.0 |  0.02
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.40247    | 0.40247    | 0.40247    |   0.0 |  0.07
Other   |            | 0.06162    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128686.0 ave      128686 max      128686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128686
Ave neighs/atom = 64.343000
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 = 313.405541465537, Press = 1.02725943141208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16017.727   -16017.727    -16095.48    -16095.48    300.90994    300.90994    36195.174    36195.174    601.36586    601.36586 
   35000   -16020.096   -16020.096   -16101.844   -16101.844    316.37611    316.37611    36196.856    36196.856    36.680868    36.680868 
Loop time of 595.058 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.294 hours/ns, 1.681 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    | 594.46     | 594.46     | 594.46     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10638    | 0.10638    | 0.10638    |   0.0 |  0.02
Output  | 0.00019619 | 0.00019619 | 0.00019619 |   0.0 |  0.00
Modify  | 0.42802    | 0.42802    | 0.42802    |   0.0 |  0.07
Other   |            | 0.06511    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128788.0 ave      128788 max      128788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128788
Ave neighs/atom = 64.394000
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 = 313.450417084389, Press = 1.21604038708938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -16020.096   -16020.096   -16101.844   -16101.844    316.37611    316.37611    36196.856    36196.856    36.680868    36.680868 
   36000   -16020.733   -16020.733   -16102.969   -16102.969    318.26246    318.26246    36150.959    36150.959    2499.7893    2499.7893 
Loop time of 588.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.436 hours/ns, 1.700 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    | 587.78     | 587.78     | 587.78     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10522    | 0.10522    | 0.10522    |   0.0 |  0.02
Output  | 0.00018372 | 0.00018372 | 0.00018372 |   0.0 |  0.00
Modify  | 0.42397    | 0.42397    | 0.42397    |   0.0 |  0.07
Other   |            | 0.06415    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128666.0 ave      128666 max      128666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128666
Ave neighs/atom = 64.333000
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 = 313.378719135675, Press = 1.46101373443025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -16020.733   -16020.733   -16102.969   -16102.969    318.26246    318.26246    36150.959    36150.959    2499.7893    2499.7893 
   37000   -16015.683   -16015.683   -16099.326   -16099.326     323.7073     323.7073    36174.256    36174.256     1659.488     1659.488 
Loop time of 604.635 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.954 hours/ns, 1.654 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    | 604.02     | 604.02     | 604.02     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.02
Output  | 0.00024017 | 0.00024017 | 0.00024017 |   0.0 |  0.00
Modify  | 0.43911    | 0.43911    | 0.43911    |   0.0 |  0.07
Other   |            | 0.06582    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128700.0 ave      128700 max      128700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128700
Ave neighs/atom = 64.350000
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 = 313.385941991663, Press = -1.04848836062703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -16015.683   -16015.683   -16099.326   -16099.326     323.7073     323.7073    36174.256    36174.256     1659.488     1659.488 
   38000   -16019.214   -16019.214   -16101.933   -16101.933    320.13055    320.13055    36226.688    36226.688   -1422.7877   -1422.7877 
Loop time of 605.457 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.183 hours/ns, 1.652 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    | 604.84     | 604.84     | 604.84     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10928    | 0.10928    | 0.10928    |   0.0 |  0.02
Output  | 0.00019253 | 0.00019253 | 0.00019253 |   0.0 |  0.00
Modify  | 0.4432     | 0.4432     | 0.4432     |   0.0 |  0.07
Other   |            | 0.06583    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128724.0 ave      128724 max      128724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128724
Ave neighs/atom = 64.362000
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 = 313.461638735586, Press = -0.524770034208907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -16019.214   -16019.214   -16101.933   -16101.933    320.13055    320.13055    36226.688    36226.688   -1422.7877   -1422.7877 
   39000   -16018.953   -16018.953   -16100.422   -16100.422    315.29143    315.29143    36210.404    36210.404   -401.49794   -401.49794 
Loop time of 552.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.156 ns/day, 153.431 hours/ns, 1.810 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    | 551.82     | 551.82     | 551.82     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097266   | 0.097266   | 0.097266   |   0.0 |  0.02
Output  | 0.00019437 | 0.00019437 | 0.00019437 |   0.0 |  0.00
Modify  | 0.37495    | 0.37495    | 0.37495    |   0.0 |  0.07
Other   |            | 0.06005    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128536.0 ave      128536 max      128536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128536
Ave neighs/atom = 64.268000
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 = 313.481671680593, Press = 0.935039869793531
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -16018.953   -16018.953   -16100.422   -16100.422    315.29143    315.29143    36210.404    36210.404   -401.49794   -401.49794 
   40000   -16018.921   -16018.921     -16100.4     -16100.4    315.33163    315.33163    36202.875    36202.875    6.9262535    6.9262535 
Loop time of 533.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 148.058 hours/ns, 1.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    | 532.5      | 532.5      | 532.5      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093227   | 0.093227   | 0.093227   |   0.0 |  0.02
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.35085    | 0.35085    | 0.35085    |   0.0 |  0.07
Other   |            | 0.05904    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128576.0 ave      128576 max      128576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128576
Ave neighs/atom = 64.288000
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 = 313.469848244433, Press = 0.768059513873458
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -16018.921   -16018.921     -16100.4     -16100.4    315.33163    315.33163    36202.875    36202.875    6.9262535    6.9262535 
   41000    -16021.19    -16021.19    -16100.79    -16100.79    308.06136    308.06136    36212.013    36212.013   -591.57057   -591.57057 
Loop time of 532.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 147.934 hours/ns, 1.878 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    | 532.06     | 532.06     | 532.06     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093077   | 0.093077   | 0.093077   |   0.0 |  0.02
Output  | 0.00015318 | 0.00015318 | 0.00015318 |   0.0 |  0.00
Modify  | 0.34965    | 0.34965    | 0.34965    |   0.0 |  0.07
Other   |            | 0.05804    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128616.0 ave      128616 max      128616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128616
Ave neighs/atom = 64.308000
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 = 313.489156222692, Press = 0.278572949250125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -16021.19    -16021.19    -16100.79    -16100.79    308.06136    308.06136    36212.013    36212.013   -591.57057   -591.57057 
   42000   -16020.655   -16020.655   -16100.718   -16100.718    309.85139    309.85139    36236.902    36236.902   -1891.3869   -1891.3869 
Loop time of 532.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 147.926 hours/ns, 1.878 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    | 532.03     | 532.03     | 532.03     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094855   | 0.094855   | 0.094855   |   0.0 |  0.02
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.3522     | 0.3522     | 0.3522     |   0.0 |  0.07
Other   |            | 0.05884    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128584.0 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292000
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 = 313.458687331797, Press = 0.657983399958004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -16020.655   -16020.655   -16100.718   -16100.718    309.85139    309.85139    36236.902    36236.902   -1891.3869   -1891.3869 
   43000   -16019.413   -16019.413   -16101.493   -16101.493    317.65917    317.65917    36169.783    36169.783    1673.2037    1673.2037 
Loop time of 531.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.163 ns/day, 147.628 hours/ns, 1.882 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    | 530.96     | 530.96     | 530.96     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095223   | 0.095223   | 0.095223   |   0.0 |  0.02
Output  | 0.00015804 | 0.00015804 | 0.00015804 |   0.0 |  0.00
Modify  | 0.3521     | 0.3521     | 0.3521     |   0.0 |  0.07
Other   |            | 0.05944    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128574.0 ave      128574 max      128574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128574
Ave neighs/atom = 64.287000
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 = 313.458485925308, Press = 1.43357818978028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -16019.413   -16019.413   -16101.493   -16101.493    317.65917    317.65917    36169.783    36169.783    1673.2037    1673.2037 
   44000   -16018.888   -16018.888   -16098.378   -16098.378    307.63649    307.63649    36163.734    36163.734    2240.8093    2240.8093 
Loop time of 534.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 148.585 hours/ns, 1.869 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    | 534.4      | 534.4      | 534.4      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095558   | 0.095558   | 0.095558   |   0.0 |  0.02
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.35391    | 0.35391    | 0.35391    |   0.0 |  0.07
Other   |            | 0.05924    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128672.0 ave      128672 max      128672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128672
Ave neighs/atom = 64.336000
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 = 313.425620909975, Press = -0.491029159139899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -16018.888   -16018.888   -16098.378   -16098.378    307.63649    307.63649    36163.734    36163.734    2240.8093    2240.8093 
   45000   -16020.628   -16020.628   -16100.268   -16100.268    308.21582    308.21582    36231.757    36231.757   -1579.3542   -1579.3542 
Loop time of 533.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.162 ns/day, 148.294 hours/ns, 1.873 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    | 533.35     | 533.35     | 533.35     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096273   | 0.096273   | 0.096273   |   0.0 |  0.02
Output  | 0.00015755 | 0.00015755 | 0.00015755 |   0.0 |  0.00
Modify  | 0.35227    | 0.35227    | 0.35227    |   0.0 |  0.07
Other   |            | 0.05845    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128822.0 ave      128822 max      128822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128822
Ave neighs/atom = 64.411000
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 = 313.45374080784, Press = 0.223542382138913
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -16020.628   -16020.628   -16100.268   -16100.268    308.21582    308.21582    36231.757    36231.757   -1579.3542   -1579.3542 
   46000   -16019.899   -16019.899   -16101.626   -16101.626    316.29459    316.29459    36222.175    36222.175   -1066.8313   -1066.8313 
Loop time of 549.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.157 ns/day, 152.681 hours/ns, 1.819 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    | 549.12     | 549.12     | 549.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09916    | 0.09916    | 0.09916    |   0.0 |  0.02
Output  | 0.00023001 | 0.00023001 | 0.00023001 |   0.0 |  0.00
Modify  | 0.3733     | 0.3733     | 0.3733     |   0.0 |  0.07
Other   |            | 0.06042    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128570.0 ave      128570 max      128570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128570
Ave neighs/atom = 64.285000
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 = 313.386366221889, Press = 1.12221053427041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -16019.899   -16019.899   -16101.626   -16101.626    316.29459    316.29459    36222.175    36222.175   -1066.8313   -1066.8313 
   47000   -16018.683   -16018.683   -16100.022   -16100.022    314.79274    314.79274    36184.756    36184.756    958.72474    958.72474 
Loop time of 559.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.154 ns/day, 155.399 hours/ns, 1.788 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    | 558.89     | 558.89     | 558.89     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.02
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.38802    | 0.38802    | 0.38802    |   0.0 |  0.07
Other   |            | 0.06172    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128606.0 ave      128606 max      128606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128606
Ave neighs/atom = 64.303000
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 = 313.360217397279, Press = 0.512733413286526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -16018.683   -16018.683   -16100.022   -16100.022    314.79274    314.79274    36184.756    36184.756    958.72474    958.72474 
   48000    -16021.38    -16021.38   -16100.309   -16100.309    305.46593    305.46593     36188.75     36188.75    632.08411    632.08411 
Loop time of 546.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.158 ns/day, 151.733 hours/ns, 1.831 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    | 545.71     | 545.71     | 545.71     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097501   | 0.097501   | 0.097501   |   0.0 |  0.02
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.36963    | 0.36963    | 0.36963    |   0.0 |  0.07
Other   |            | 0.05942    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128662.0 ave      128662 max      128662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128662
Ave neighs/atom = 64.331000
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 = 313.305115124663, Press = 0.685146133468645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -16021.38    -16021.38   -16100.309   -16100.309    305.46593    305.46593     36188.75     36188.75    632.08411    632.08411 
   49000   -16016.208   -16016.208    -16098.89    -16098.89    319.98641    319.98641    36162.844    36162.844    2294.3182    2294.3182 
Loop time of 597.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.869 hours/ns, 1.675 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    | 596.52     | 596.52     | 596.52     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10791    | 0.10791    | 0.10791    |   0.0 |  0.02
Output  | 0.00015518 | 0.00015518 | 0.00015518 |   0.0 |  0.00
Modify  | 0.42848    | 0.42848    | 0.42848    |   0.0 |  0.07
Other   |            | 0.06512    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128640.0 ave      128640 max      128640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128640
Ave neighs/atom = 64.320000
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 = 313.294787677862, Press = -1.09424055021128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -16016.208   -16016.208    -16098.89    -16098.89    319.98641    319.98641    36162.844    36162.844    2294.3182    2294.3182 
   50000   -16016.745   -16016.745   -16097.656   -16097.656    313.13444    313.13444    36233.598    36233.598   -1371.7929   -1371.7929 
Loop time of 602.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.477 hours/ns, 1.659 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    | 602.31     | 602.31     | 602.31     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10877    | 0.10877    | 0.10877    |   0.0 |  0.02
Output  | 0.00014988 | 0.00014988 | 0.00014988 |   0.0 |  0.00
Modify  | 0.43678    | 0.43678    | 0.43678    |   0.0 |  0.07
Other   |            | 0.06639    |            |       |  0.01

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128742.0 ave      128742 max      128742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128742
Ave neighs/atom = 64.371000
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
36201.0998233317

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0