# 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.303000025451184*${_u_distance}
variable latticeconst_converted equal 3.303000025451184*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30300002545118
Lattice spacing in x,y,z = 3.3030000 3.3030000 3.3030000
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.030000 33.030000 33.030000)
  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.030000 33.030000 33.030000)
  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_GaoOteroAouadi_2013_AgTaO__MO_112077942578_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 36035.0999600026    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36035.0999600026/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36035.0999600026/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 36035.0999600026/(1*1*${_u_distance})
variable      V0_metal equal 36035.0999600026/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 36035.0999600026*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36035.0999600026 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_112077942578_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -16099.085   -16099.085       -16180       -16180       313.15       313.15      36035.1      36035.1    2398.3751    2398.3751 
    1000   -16019.971   -16019.971    -16104.74    -16104.74    328.06371    328.06371    36384.132    36384.132    -3919.729    -3919.729 
Loop time of 160.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.538 ns/day, 44.624 hours/ns, 6.225 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    | 160.11     | 160.11     | 160.11     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10339    | 0.10339    | 0.10339    |   0.0 |  0.06
Output  | 0.00020754 | 0.00020754 | 0.00020754 |   0.0 |  0.00
Modify  | 0.36686    | 0.36686    | 0.36686    |   0.0 |  0.23
Other   |            | 0.06128    |            |       |  0.04

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:      272000.0 ave      272000 max      272000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272000
Ave neighs/atom = 136.00000
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 = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16019.971   -16019.971    -16104.74    -16104.74    328.06371    328.06371    36384.132    36384.132    -3919.729    -3919.729 
    2000   -16018.909   -16018.909   -16098.325   -16098.325    307.34984    307.34984    36338.611    36338.611     -354.974     -354.974 
Loop time of 168.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.888 hours/ns, 5.924 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    | 168.21     | 168.21     | 168.21     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11045    | 0.11045    | 0.11045    |   0.0 |  0.07
Output  | 0.00024162 | 0.00024162 | 0.00024162 |   0.0 |  0.00
Modify  | 0.4076     | 0.4076     | 0.4076     |   0.0 |  0.24
Other   |            | 0.06502    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4253.00 ave        4253 max        4253 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:      262806.0 ave      262806 max      262806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262806
Ave neighs/atom = 131.40300
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 = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -16018.909   -16018.909   -16098.325   -16098.325    307.34984    307.34984    36338.611    36338.611     -354.974     -354.974 
    3000    -16024.14    -16024.14   -16101.026   -16101.026    297.55588    297.55588     36302.11     36302.11    703.67966    703.67966 
Loop time of 173.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.131 hours/ns, 5.771 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.67     | 172.67     | 172.67     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11387    | 0.11387    | 0.11387    |   0.0 |  0.07
Output  | 0.00023704 | 0.00023704 | 0.00023704 |   0.0 |  0.00
Modify  | 0.41956    | 0.41956    | 0.41956    |   0.0 |  0.24
Other   |            | 0.06652    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4258.00 ave        4258 max        4258 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:      262840.0 ave      262840 max      262840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262840
Ave neighs/atom = 131.42000
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 = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -16024.14    -16024.14   -16101.026   -16101.026    297.55588    297.55588     36302.11     36302.11    703.67966    703.67966 
    4000   -16019.695   -16019.695   -16099.814   -16099.814    310.06982    310.06982    36282.874    36282.874    2061.3031    2061.3031 
Loop time of 174.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.366 hours/ns, 5.743 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    | 173.52     | 173.52     | 173.52     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11494    | 0.11494    | 0.11494    |   0.0 |  0.07
Output  | 0.00023873 | 0.00023873 | 0.00023873 |   0.0 |  0.00
Modify  | 0.41548    | 0.41548    | 0.41548    |   0.0 |  0.24
Other   |            | 0.06705    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4275.00 ave        4275 max        4275 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:      263228.0 ave      263228 max      263228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263228
Ave neighs/atom = 131.61400
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 = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -16019.695   -16019.695   -16099.814   -16099.814    310.06982    310.06982    36282.874    36282.874    2061.3031    2061.3031 
    5000   -16020.046   -16020.046   -16101.551   -16101.551    315.43036    315.43036    36299.351    36299.351    982.52329    982.52329 
Loop time of 173.785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.274 hours/ns, 5.754 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    | 173.18     | 173.18     | 173.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11461    | 0.11461    | 0.11461    |   0.0 |  0.07
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.42115    | 0.42115    | 0.42115    |   0.0 |  0.24
Other   |            | 0.06637    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4279.00 ave        4279 max        4279 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:      263458.0 ave      263458 max      263458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263458
Ave neighs/atom = 131.72900
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 = 315.109240784699, Press = -598.463076760425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16020.046   -16020.046   -16101.551   -16101.551    315.43036    315.43036    36299.351    36299.351    982.52329    982.52329 
    6000   -16020.774   -16020.774   -16100.648   -16100.648     309.1203     309.1203    36314.764    36314.764    286.41993    286.41993 
Loop time of 158.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.977 hours/ns, 6.316 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.76     | 157.76     | 157.76     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10628    | 0.10628    | 0.10628    |   0.0 |  0.07
Output  | 0.00015701 | 0.00015701 | 0.00015701 |   0.0 |  0.00
Modify  | 0.38488    | 0.38488    | 0.38488    |   0.0 |  0.24
Other   |            | 0.0627     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4259.00 ave        4259 max        4259 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:      263494.0 ave      263494 max      263494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263494
Ave neighs/atom = 131.74700
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 = 312.772956022645, Press = -14.3739879028827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16020.774   -16020.774   -16100.648   -16100.648     309.1203     309.1203    36314.764    36314.764    286.41993    286.41993 
    7000   -16017.297   -16017.297   -16100.762   -16100.762    323.01824    323.01824    36314.867    36314.867    426.23132    426.23132 
Loop time of 147.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.106 hours/ns, 6.758 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    | 147.47     | 147.47     | 147.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10168    | 0.10168    | 0.10168    |   0.0 |  0.07
Output  | 0.00019953 | 0.00019953 | 0.00019953 |   0.0 |  0.00
Modify  | 0.35213    | 0.35213    | 0.35213    |   0.0 |  0.24
Other   |            | 0.05946    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4278.00 ave        4278 max        4278 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:      263190.0 ave      263190 max      263190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263190
Ave neighs/atom = 131.59500
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.173678143781, Press = -49.2394163396321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -16017.297   -16017.297   -16100.762   -16100.762    323.01824    323.01824    36314.867    36314.867    426.23132    426.23132 
    8000   -16021.464   -16021.464       -16102       -16102    311.67946    311.67946    36329.157    36329.157   -531.66928   -531.66928 
Loop time of 148.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.137 hours/ns, 6.753 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    | 147.58     | 147.58     | 147.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10089    | 0.10089    | 0.10089    |   0.0 |  0.07
Output  | 0.00019962 | 0.00019962 | 0.00019962 |   0.0 |  0.00
Modify  | 0.35307    | 0.35307    | 0.35307    |   0.0 |  0.24
Other   |            | 0.0595     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4280.00 ave        4280 max        4280 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:      263300.0 ave      263300 max      263300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263300
Ave neighs/atom = 131.65000
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.041657635848, Press = -13.3392703851379
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16021.464   -16021.464       -16102       -16102    311.67946    311.67946    36329.157    36329.157   -531.66928   -531.66928 
    9000   -16017.591   -16017.591    -16097.88    -16097.88    310.72804    310.72804     36260.47     36260.47    3442.0383    3442.0383 
Loop time of 157.695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.804 hours/ns, 6.341 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    | 157.14     | 157.14     | 157.14     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1056     | 0.1056     | 0.1056     |   0.0 |  0.07
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.39026    | 0.39026    | 0.39026    |   0.0 |  0.25
Other   |            | 0.06174    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4288.00 ave        4288 max        4288 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:      263106.0 ave      263106 max      263106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263106
Ave neighs/atom = 131.55300
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.271392113273, Press = -4.92367597178119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -16017.591   -16017.591    -16097.88    -16097.88    310.72804    310.72804     36260.47     36260.47    3442.0383    3442.0383 
   10000   -16020.857   -16020.857   -16102.855   -16102.855    317.34086    317.34086    36365.179    36365.179   -2581.8972   -2581.8972 
Loop time of 153.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.686 hours/ns, 6.507 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    | 153.13     | 153.13     | 153.13     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10518    | 0.10518    | 0.10518    |   0.0 |  0.07
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.37128    | 0.37128    | 0.37128    |   0.0 |  0.24
Other   |            | 0.06134    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4290.00 ave        4290 max        4290 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:      263488.0 ave      263488 max      263488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263488
Ave neighs/atom = 131.74400
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.804979694824, Press = -9.10369986045124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -16020.857   -16020.857   -16102.855   -16102.855    317.34086    317.34086    36365.179    36365.179   -2581.8972   -2581.8972 
   11000   -16020.726   -16020.726   -16100.784   -16100.784    309.83096    309.83096     36337.38     36337.38    -880.1498    -880.1498 
Loop time of 147.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.074 hours/ns, 6.763 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    | 147.35     | 147.35     | 147.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10201    | 0.10201    | 0.10201    |   0.0 |  0.07
Output  | 0.00015779 | 0.00015779 | 0.00015779 |   0.0 |  0.00
Modify  | 0.34958    | 0.34958    | 0.34958    |   0.0 |  0.24
Other   |            | 0.05945    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4246.00 ave        4246 max        4246 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:      262786.0 ave      262786 max      262786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262786
Ave neighs/atom = 131.39300
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.885815662206, Press = 5.00803256961987
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16020.726   -16020.726   -16100.784   -16100.784    309.83096    309.83096     36337.38     36337.38    -880.1498    -880.1498 
   12000   -16019.396   -16019.396   -16100.529   -16100.529    313.99151    313.99151    36299.465    36299.465    1205.5964    1205.5964 
Loop time of 147.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.586 ns/day, 40.944 hours/ns, 6.784 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    | 146.89     | 146.89     | 146.89     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10159    | 0.10159    | 0.10159    |   0.0 |  0.07
Output  | 0.00015915 | 0.00015915 | 0.00015915 |   0.0 |  0.00
Modify  | 0.35013    | 0.35013    | 0.35013    |   0.0 |  0.24
Other   |            | 0.05955    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4265.00 ave        4265 max        4265 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:      262930.0 ave      262930 max      262930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262930
Ave neighs/atom = 131.46500
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.891963297574, Press = -7.2730445971389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16019.396   -16019.396   -16100.529   -16100.529    313.99151    313.99151    36299.465    36299.465    1205.5964    1205.5964 
   13000   -16017.954   -16017.954   -16100.987   -16100.987    321.34704    321.34704    36306.184    36306.184    723.05467    723.05467 
Loop time of 148.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.134 hours/ns, 6.753 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    | 147.57     | 147.57     | 147.57     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10262    | 0.10262    | 0.10262    |   0.0 |  0.07
Output  | 0.00020158 | 0.00020158 | 0.00020158 |   0.0 |  0.00
Modify  | 0.34953    | 0.34953    | 0.34953    |   0.0 |  0.24
Other   |            | 0.06022    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4307.00 ave        4307 max        4307 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:      263146.0 ave      263146 max      263146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263146
Ave neighs/atom = 131.57300
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.99164292573, Press = -0.28460211486567
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16017.954   -16017.954   -16100.987   -16100.987    321.34704    321.34704    36306.184    36306.184    723.05467    723.05467 
   14000   -16023.575   -16023.575   -16101.845   -16101.845    302.91376    302.91376    36344.879    36344.879   -1449.3918   -1449.3918 
Loop time of 147.088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.858 hours/ns, 6.799 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    | 146.58     | 146.58     | 146.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10273    | 0.10273    | 0.10273    |   0.0 |  0.07
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.35025    | 0.35025    | 0.35025    |   0.0 |  0.24
Other   |            | 0.05972    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4282.00 ave        4282 max        4282 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:      263222.0 ave      263222 max      263222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263222
Ave neighs/atom = 131.61100
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.96824764287, Press = -2.11478014874212
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -16023.575   -16023.575   -16101.845   -16101.845    302.91376    302.91376    36344.879    36344.879   -1449.3918   -1449.3918 
   15000    -16020.59    -16020.59    -16101.11    -16101.11    311.61962    311.61962    36326.319    36326.319   -313.83998   -313.83998 
Loop time of 147.28 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.911 hours/ns, 6.790 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    | 146.77     | 146.77     | 146.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.102      | 0.102      | 0.102      |   0.0 |  0.07
Output  | 0.00015724 | 0.00015724 | 0.00015724 |   0.0 |  0.00
Modify  | 0.3502     | 0.3502     | 0.3502     |   0.0 |  0.24
Other   |            | 0.05952    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4246.00 ave        4246 max        4246 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:      262958.0 ave      262958 max      262958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262958
Ave neighs/atom = 131.47900
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.783050688123, Press = 0.316187822915181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -16020.59    -16020.59    -16101.11    -16101.11    311.61962    311.61962    36326.319    36326.319   -313.83998   -313.83998 
   16000   -16022.661   -16022.661   -16102.337   -16102.337    308.35117    308.35117    36326.688    36326.688   -702.98086   -702.98086 
Loop time of 147.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.007 hours/ns, 6.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    | 147.11     | 147.11     | 147.11     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10185    | 0.10185    | 0.10185    |   0.0 |  0.07
Output  | 0.00015678 | 0.00015678 | 0.00015678 |   0.0 |  0.00
Modify  | 0.35118    | 0.35118    | 0.35118    |   0.0 |  0.24
Other   |            | 0.05964    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4262.00 ave        4262 max        4262 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:      263020.0 ave      263020 max      263020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263020
Ave neighs/atom = 131.51000
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.657059454697, Press = -3.55027902093506
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -16022.661   -16022.661   -16102.337   -16102.337    308.35117    308.35117    36326.688    36326.688   -702.98086   -702.98086 
   17000   -16022.362   -16022.362   -16101.584   -16101.584    306.59848    306.59848    36339.933    36339.933   -1370.3944   -1370.3944 
Loop time of 148.016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.116 hours/ns, 6.756 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    | 147.5      | 147.5      | 147.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10216    | 0.10216    | 0.10216    |   0.0 |  0.07
Output  | 0.00018881 | 0.00018881 | 0.00018881 |   0.0 |  0.00
Modify  | 0.35059    | 0.35059    | 0.35059    |   0.0 |  0.24
Other   |            | 0.05963    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4279.00 ave        4279 max        4279 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:      263284.0 ave      263284 max      263284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263284
Ave neighs/atom = 131.64200
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.562492789502, Press = 2.37111305500125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16022.362   -16022.362   -16101.584   -16101.584    306.59848    306.59848    36339.933    36339.933   -1370.3944   -1370.3944 
   18000   -16021.486   -16021.486   -16102.148   -16102.148    312.17083    312.17083    36341.616    36341.616   -1419.9798   -1419.9798 
Loop time of 149.041 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.400 hours/ns, 6.710 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    | 148.52     | 148.52     | 148.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10222    | 0.10222    | 0.10222    |   0.0 |  0.07
Output  | 0.00023589 | 0.00023589 | 0.00023589 |   0.0 |  0.00
Modify  | 0.35538    | 0.35538    | 0.35538    |   0.0 |  0.24
Other   |            | 0.0605     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4244.00 ave        4244 max        4244 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:      263000.0 ave      263000 max      263000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263000
Ave neighs/atom = 131.50000
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.300187572034, Press = -3.68004984572113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16021.486   -16021.486   -16102.148   -16102.148    312.17083    312.17083    36341.616    36341.616   -1419.9798   -1419.9798 
   19000   -16018.065   -16018.065   -16100.407   -16100.407    318.67118    318.67118    36322.744    36322.744   -131.83048   -131.83048 
Loop time of 151.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.079 hours/ns, 6.601 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    | 150.95     | 150.95     | 150.95     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10424    | 0.10424    | 0.10424    |   0.0 |  0.07
Output  | 0.00016095 | 0.00016095 | 0.00016095 |   0.0 |  0.00
Modify  | 0.36749    | 0.36749    | 0.36749    |   0.0 |  0.24
Other   |            | 0.06061    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4305.00 ave        4305 max        4305 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:      262582.0 ave      262582 max      262582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262582
Ave neighs/atom = 131.29100
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.211266744328, Press = 0.540559588449605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -16018.065   -16018.065   -16100.407   -16100.407    318.67118    318.67118    36322.744    36322.744   -131.83048   -131.83048 
   20000   -16022.693   -16022.693    -16102.41    -16102.41    308.51248    308.51248    36338.933    36338.933   -1150.4492   -1150.4492 
Loop time of 172.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.952 hours/ns, 5.793 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    | 172.01     | 172.01     | 172.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11548    | 0.11548    | 0.11548    |   0.0 |  0.07
Output  | 0.00015747 | 0.00015747 | 0.00015747 |   0.0 |  0.00
Modify  | 0.4334     | 0.4334     | 0.4334     |   0.0 |  0.25
Other   |            | 0.06622    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4282.00 ave        4282 max        4282 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:      263044.0 ave      263044 max      263044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263044
Ave neighs/atom = 131.52200
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.336091238204, Press = -4.0365608620532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16022.693   -16022.693    -16102.41    -16102.41    308.51248    308.51248    36338.933    36338.933   -1150.4492   -1150.4492 
   21000   -16020.192   -16020.192   -16101.994   -16101.994    316.58127    316.58127    36344.823    36344.823   -1322.0657   -1322.0657 
Loop time of 173.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.082 hours/ns, 5.777 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    | 172.47     | 172.47     | 172.47     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11375    | 0.11375    | 0.11375    |   0.0 |  0.07
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.44154    | 0.44154    | 0.44154    |   0.0 |  0.26
Other   |            | 0.06661    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4253.00 ave        4253 max        4253 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:      262998.0 ave      262998 max      262998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262998
Ave neighs/atom = 131.49900
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.391046443146, Press = -1.2976212371718
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16020.192   -16020.192   -16101.994   -16101.994    316.58127    316.58127    36344.823    36344.823   -1322.0657   -1322.0657 
   22000   -16020.938   -16020.938   -16103.148   -16103.148    318.16191    318.16191     36267.72     36267.72    2379.1292    2379.1292 
Loop time of 174.049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.347 hours/ns, 5.746 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    | 173.43     | 173.43     | 173.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11231    | 0.11231    | 0.11231    |   0.0 |  0.06
Output  | 0.00018994 | 0.00018994 | 0.00018994 |   0.0 |  0.00
Modify  | 0.4431     | 0.4431     | 0.4431     |   0.0 |  0.25
Other   |            | 0.06616    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4251.00 ave        4251 max        4251 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:      262800.0 ave      262800 max      262800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262800
Ave neighs/atom = 131.40000
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.316108565614, Press = 1.22833785483095
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -16020.938   -16020.938   -16103.148   -16103.148    318.16191    318.16191     36267.72     36267.72    2379.1292    2379.1292 
   23000   -16020.603   -16020.603   -16100.834   -16100.834    310.50241    310.50241    36343.412    36343.412   -1159.2564   -1159.2564 
Loop time of 153.769 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.714 hours/ns, 6.503 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    | 153.23     | 153.23     | 153.23     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10662    | 0.10662    | 0.10662    |   0.0 |  0.07
Output  | 0.00015608 | 0.00015608 | 0.00015608 |   0.0 |  0.00
Modify  | 0.3697     | 0.3697     | 0.3697     |   0.0 |  0.24
Other   |            | 0.06082    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4296.00 ave        4296 max        4296 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:      263668.0 ave      263668 max      263668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263668
Ave neighs/atom = 131.83400
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.308062726943, Press = -4.41790141362052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -16020.603   -16020.603   -16100.834   -16100.834    310.50241    310.50241    36343.412    36343.412   -1159.2564   -1159.2564 
   24000   -16025.151   -16025.151   -16104.588   -16104.588    307.42886    307.42886    36335.893    36335.893   -1317.9996   -1317.9996 
Loop time of 160.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.538 ns/day, 44.585 hours/ns, 6.230 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    | 159.94     | 159.94     | 159.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.07
Output  | 0.00027291 | 0.00027291 | 0.00027291 |   0.0 |  0.00
Modify  | 0.39423    | 0.39423    | 0.39423    |   0.0 |  0.25
Other   |            | 0.06324    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4277.00 ave        4277 max        4277 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:      262760.0 ave      262760 max      262760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262760
Ave neighs/atom = 131.38000
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.271194611651, Press = -2.56283799625241
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16025.151   -16025.151   -16104.588   -16104.588    307.42886    307.42886    36335.893    36335.893   -1317.9996   -1317.9996 
   25000   -16019.458   -16019.458   -16098.842   -16098.842    307.22522    307.22522    36364.677    36364.677   -1989.4486   -1989.4486 
Loop time of 174.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.458 hours/ns, 5.732 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    | 173.83     | 173.83     | 173.83     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11432    | 0.11432    | 0.11432    |   0.0 |  0.07
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.4426     | 0.4426     | 0.4426     |   0.0 |  0.25
Other   |            | 0.06727    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4246.00 ave        4246 max        4246 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:      263304.0 ave      263304 max      263304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263304
Ave neighs/atom = 131.65200
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.173048921175, Press = -1.15419595459868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16019.458   -16019.458   -16098.842   -16098.842    307.22522    307.22522    36364.677    36364.677   -1989.4486   -1989.4486 
   26000   -16019.142   -16019.142   -16100.044   -16100.044      313.098      313.098    36377.976    36377.976   -2552.9908   -2552.9908 
Loop time of 173.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.168 hours/ns, 5.767 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    | 172.79     | 172.79     | 172.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11464    | 0.11464    | 0.11464    |   0.0 |  0.07
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.43618    | 0.43618    | 0.43618    |   0.0 |  0.25
Other   |            | 0.06646    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4233.00 ave        4233 max        4233 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:      262606.0 ave      262606 max      262606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262606
Ave neighs/atom = 131.30300
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.081636276977, Press = -4.28278675883642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16019.142   -16019.142   -16100.044   -16100.044      313.098      313.098    36377.976    36377.976   -2552.9908   -2552.9908 
   27000   -16026.429   -16026.429   -16106.323   -16106.323    309.19884    309.19884    36333.185    36333.185   -1635.4454   -1635.4454 
Loop time of 156.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.552 ns/day, 43.479 hours/ns, 6.389 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    | 155.97     | 155.97     | 155.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10588    | 0.10588    | 0.10588    |   0.0 |  0.07
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.38276    | 0.38276    | 0.38276    |   0.0 |  0.24
Other   |            | 0.06227    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4256.00 ave        4256 max        4256 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:      262490.0 ave      262490 max      262490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262490
Ave neighs/atom = 131.24500
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.043466172653, Press = -0.306994771194018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -16026.429   -16026.429   -16106.323   -16106.323    309.19884    309.19884    36333.185    36333.185   -1635.4454   -1635.4454 
   28000   -16020.234   -16020.234   -16101.599   -16101.599    314.89044    314.89044    36317.448    36317.448     71.31489     71.31489 
Loop time of 147.564 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.586 ns/day, 40.990 hours/ns, 6.777 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    | 147.05     | 147.05     | 147.05     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10122    | 0.10122    | 0.10122    |   0.0 |  0.07
Output  | 0.00015637 | 0.00015637 | 0.00015637 |   0.0 |  0.00
Modify  | 0.34895    | 0.34895    | 0.34895    |   0.0 |  0.24
Other   |            | 0.0586     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4281.00 ave        4281 max        4281 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:      263468.0 ave      263468 max      263468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263468
Ave neighs/atom = 131.73400
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 = 312.952127131169, Press = -1.43097011714246
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -16020.234   -16020.234   -16101.599   -16101.599    314.89044    314.89044    36317.448    36317.448     71.31489     71.31489 
   29000   -16019.258   -16019.258   -16101.265   -16101.265    317.37478    317.37478    36337.255    36337.255   -780.51949   -780.51949 
Loop time of 164.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.525 ns/day, 45.699 hours/ns, 6.078 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    | 163.94     | 163.94     | 163.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11038    | 0.11038    | 0.11038    |   0.0 |  0.07
Output  | 0.00019804 | 0.00019804 | 0.00019804 |   0.0 |  0.00
Modify  | 0.40555    | 0.40555    | 0.40555    |   0.0 |  0.25
Other   |            | 0.06415    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4299.00 ave        4299 max        4299 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:      263002.0 ave      263002 max      263002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263002
Ave neighs/atom = 131.50100
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 = 312.97903112548, Press = -1.12276109799071
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -16019.258   -16019.258   -16101.265   -16101.265    317.37478    317.37478    36337.255    36337.255   -780.51949   -780.51949 
   30000   -16020.406   -16020.406   -16100.295   -16100.295    309.17857    309.17857    36325.884    36325.884    -315.7383    -315.7383 
Loop time of 172.636 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 47.954 hours/ns, 5.793 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    | 172.02     | 172.02     | 172.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11517    | 0.11517    | 0.11517    |   0.0 |  0.07
Output  | 0.00015779 | 0.00015779 | 0.00015779 |   0.0 |  0.00
Modify  | 0.43262    | 0.43262    | 0.43262    |   0.0 |  0.25
Other   |            | 0.06618    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4305.00 ave        4305 max        4305 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:      262964.0 ave      262964 max      262964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262964
Ave neighs/atom = 131.48200
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 = 312.999961469465, Press = -1.4608006628741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -16020.406   -16020.406   -16100.295   -16100.295    309.17857    309.17857    36325.884    36325.884    -315.7383    -315.7383 
   31000    -16018.85    -16018.85   -16101.996   -16101.996    321.78359    321.78359    36336.927    36336.927   -868.36968   -868.36968 
Loop time of 167.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.516 ns/day, 46.513 hours/ns, 5.972 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    | 166.85     | 166.85     | 166.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11152    | 0.11152    | 0.11152    |   0.0 |  0.07
Output  | 0.00019879 | 0.00019879 | 0.00019879 |   0.0 |  0.00
Modify  | 0.41746    | 0.41746    | 0.41746    |   0.0 |  0.25
Other   |            | 0.06478    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4263.00 ave        4263 max        4263 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:      263082.0 ave      263082 max      263082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263082
Ave neighs/atom = 131.54100
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.0144058251, Press = 1.22314162462289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -16018.85    -16018.85   -16101.996   -16101.996    321.78359    321.78359    36336.927    36336.927   -868.36968   -868.36968 
   32000   -16018.045   -16018.045   -16101.314   -16101.314    322.25989    322.25989    36301.976    36301.976     756.6319     756.6319 
Loop time of 166.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.518 ns/day, 46.363 hours/ns, 5.991 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    | 166.31     | 166.31     | 166.31     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11277    | 0.11277    | 0.11277    |   0.0 |  0.07
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.41412    | 0.41412    | 0.41412    |   0.0 |  0.25
Other   |            | 0.06473    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4285.00 ave        4285 max        4285 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:      263048.0 ave      263048 max      263048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263048
Ave neighs/atom = 131.52400
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.101820282587, Press = -1.02738777431194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -16018.045   -16018.045   -16101.314   -16101.314    322.25989    322.25989    36301.976    36301.976     756.6319     756.6319 
   33000   -16018.947   -16018.947   -16100.497   -16100.497    315.60862    315.60862    36351.647    36351.647   -1511.8834   -1511.8834 
Loop time of 166.759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.518 ns/day, 46.322 hours/ns, 5.997 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    | 166.16     | 166.16     | 166.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11327    | 0.11327    | 0.11327    |   0.0 |  0.07
Output  | 0.00015663 | 0.00015663 | 0.00015663 |   0.0 |  0.00
Modify  | 0.41727    | 0.41727    | 0.41727    |   0.0 |  0.25
Other   |            | 0.06517    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4326.00 ave        4326 max        4326 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:      263304.0 ave      263304 max      263304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263304
Ave neighs/atom = 131.65200
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.122088197504, Press = -1.09569899756254
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16018.947   -16018.947   -16100.497   -16100.497    315.60862    315.60862    36351.647    36351.647   -1511.8834   -1511.8834 
   34000   -16021.589   -16021.589   -16100.486   -16100.486    305.33966    305.33966    36286.702    36286.702    1717.1316    1717.1316 
Loop time of 156.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.551 ns/day, 43.560 hours/ns, 6.377 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    | 156.26     | 156.26     | 156.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10713    | 0.10713    | 0.10713    |   0.0 |  0.07
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.38373    | 0.38373    | 0.38373    |   0.0 |  0.24
Other   |            | 0.06185    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4288.00 ave        4288 max        4288 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:      262954.0 ave      262954 max      262954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262954
Ave neighs/atom = 131.47700
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.199760163658, Press = 0.366515878923293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16021.589   -16021.589   -16100.486   -16100.486    305.33966    305.33966    36286.702    36286.702    1717.1316    1717.1316 
   35000   -16020.097   -16020.097   -16099.378   -16099.378    306.82754    306.82754    36310.605    36310.605    837.48207    837.48207 
Loop time of 174.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.410 hours/ns, 5.738 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    | 173.65     | 173.65     | 173.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11519    | 0.11519    | 0.11519    |   0.0 |  0.07
Output  | 0.0001979  | 0.0001979  | 0.0001979  |   0.0 |  0.00
Modify  | 0.44012    | 0.44012    | 0.44012    |   0.0 |  0.25
Other   |            | 0.06837    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4265.00 ave        4265 max        4265 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:      263234.0 ave      263234 max      263234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263234
Ave neighs/atom = 131.61700
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.224228766877, Press = -1.14245399117498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -16020.097   -16020.097   -16099.378   -16099.378    306.82754    306.82754    36310.605    36310.605    837.48207    837.48207 
   36000   -16018.464   -16018.464    -16100.95    -16100.95     319.2294     319.2294    36301.594    36301.594    856.70703    856.70703 
Loop time of 159.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.542 ns/day, 44.256 hours/ns, 6.277 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    | 158.76     | 158.76     | 158.76     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.07
Output  | 0.00019777 | 0.00019777 | 0.00019777 |   0.0 |  0.00
Modify  | 0.39139    | 0.39139    | 0.39139    |   0.0 |  0.25
Other   |            | 0.06285    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4253.00 ave        4253 max        4253 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:      263236.0 ave      263236 max      263236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263236
Ave neighs/atom = 131.61800
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
36318.9183531294

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0