# 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.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
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.024436 33.024436 33.024436)
  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.024436 33.024436 33.024436)
  create_atoms CPU = 0.004 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_LeeBaskesKim_2001_Ta__MO_644143102837_000
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 36016.8901176252    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*1*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 36016.8901176252*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -16093.917   -16093.917       -16180       -16180       333.15       333.15     36016.89     36016.89    2552.8614    2552.8614 
    1000   -16003.809   -16003.809   -16079.497   -16079.497    292.92155    292.92155    36151.149    36151.149    4628.7707    4628.7707 
Loop time of 100.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.806 hours/ns, 9.990 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    | 99.596     | 99.596     | 99.596     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078309   | 0.078309   | 0.078309   |   0.0 |  0.08
Output  | 0.00020198 | 0.00020198 | 0.00020198 |   0.0 |  0.00
Modify  | 0.36808    | 0.36808    | 0.36808    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16003.809   -16003.809   -16079.497   -16079.497    292.92155    292.92155    36151.149    36151.149    4628.7707    4628.7707 
    2000   -16002.875   -16002.875   -16093.019   -16093.019     348.8643     348.8643    36231.259    36231.259   -927.20664   -927.20664 
Loop time of 99.4652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.629 hours/ns, 10.054 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    | 98.978     | 98.978     | 98.978     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077298   | 0.077298   | 0.077298   |   0.0 |  0.08
Output  | 0.00025725 | 0.00025725 | 0.00025725 |   0.0 |  0.00
Modify  | 0.35313    | 0.35313    | 0.35313    |   0.0 |  0.36
Other   |            | 0.05691    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -16002.875   -16002.875   -16093.019   -16093.019     348.8643     348.8643    36231.259    36231.259   -927.20664   -927.20664 
    3000   -16006.035   -16006.035   -16096.223   -16096.223    349.03915    349.03915    36187.564    36187.564    1206.3542    1206.3542 
Loop time of 104.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.010 hours/ns, 9.575 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    | 103.91     | 103.91     | 103.91     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080263   | 0.080263   | 0.080263   |   0.0 |  0.08
Output  | 0.00025384 | 0.00025384 | 0.00025384 |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  0.37
Other   |            | 0.05869    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -16006.035   -16006.035   -16096.223   -16096.223    349.03915    349.03915    36187.564    36187.564    1206.3542    1206.3542 
    4000   -16005.734   -16005.734   -16088.043   -16088.043    318.54344    318.54344    36210.639    36210.639    534.53522    534.53522 
Loop time of 108.299 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.083 hours/ns, 9.234 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    | 107.76     | 107.76     | 107.76     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082453   | 0.082453   | 0.082453   |   0.0 |  0.08
Output  | 0.0002463  | 0.0002463  | 0.0002463  |   0.0 |  0.00
Modify  | 0.40091    | 0.40091    | 0.40091    |   0.0 |  0.37
Other   |            | 0.06008    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -16005.734   -16005.734   -16088.043   -16088.043    318.54344    318.54344    36210.639    36210.639    534.53522    534.53522 
    5000   -16005.726   -16005.726   -16092.206   -16092.206    334.68961    334.68961    36232.178    36232.178   -1118.6335   -1118.6335 
Loop time of 105.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.352 hours/ns, 9.464 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    | 105.14     | 105.14     | 105.14     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080456   | 0.080456   | 0.080456   |   0.0 |  0.08
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.38736    | 0.38736    | 0.38736    |   0.0 |  0.37
Other   |            | 0.05953    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115954.0 ave      115954 max      115954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115954
Ave neighs/atom = 57.977000
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 = 322.93172185671, Press = -314.778520691177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16005.726   -16005.726   -16092.206   -16092.206    334.68961    334.68961    36232.178    36232.178   -1118.6335   -1118.6335 
    6000   -16006.802   -16006.802   -16089.518   -16089.518    320.11834    320.11834    36259.594    36259.594   -2228.2798   -2228.2798 
Loop time of 105.602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.334 hours/ns, 9.469 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    | 105.06     | 105.06     | 105.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080663   | 0.080663   | 0.080663   |   0.0 |  0.08
Output  | 0.00023782 | 0.00023782 | 0.00023782 |   0.0 |  0.00
Modify  | 0.40174    | 0.40174    | 0.40174    |   0.0 |  0.38
Other   |            | 0.05904    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 332.350767685967, Press = 0.905890908165625
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16006.802   -16006.802   -16089.518   -16089.518    320.11834    320.11834    36259.594    36259.594   -2228.2798   -2228.2798 
    7000    -16006.92    -16006.92   -16087.881   -16087.881    313.32654    313.32654    36188.657    36188.657    1652.2234    1652.2234 
Loop time of 105.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.167 hours/ns, 9.524 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    | 104.46     | 104.46     | 104.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080621   | 0.080621   | 0.080621   |   0.0 |  0.08
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.39854    | 0.39854    | 0.39854    |   0.0 |  0.38
Other   |            | 0.05879    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 332.836168798272, Press = 23.5964857707651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -16006.92    -16006.92   -16087.881   -16087.881    313.32654    313.32654    36188.657    36188.657    1652.2234    1652.2234 
    8000   -16004.399   -16004.399   -16096.533   -16096.533    356.56851    356.56851     36257.93     36257.93   -2520.7199   -2520.7199 
Loop time of 107.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.797 hours/ns, 9.322 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    | 106.72     | 106.72     | 106.72     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081506   | 0.081506   | 0.081506   |   0.0 |  0.08
Output  | 0.00015364 | 0.00015364 | 0.00015364 |   0.0 |  0.00
Modify  | 0.41197    | 0.41197    | 0.41197    |   0.0 |  0.38
Other   |            | 0.05969    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115944.0 ave      115944 max      115944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115944
Ave neighs/atom = 57.972000
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 = 332.923505648305, Press = -1.08476137705587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16004.399   -16004.399   -16096.533   -16096.533    356.56851    356.56851     36257.93     36257.93   -2520.7199   -2520.7199 
    9000    -16005.26    -16005.26   -16095.706   -16095.706    350.03503    350.03503    36190.206    36190.206    1243.8154    1243.8154 
Loop time of 107.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.772 hours/ns, 9.330 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    | 106.62     | 106.62     | 106.62     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081537   | 0.081537   | 0.081537   |   0.0 |  0.08
Output  | 0.0001551  | 0.0001551  | 0.0001551  |   0.0 |  0.00
Modify  | 0.41203    | 0.41203    | 0.41203    |   0.0 |  0.38
Other   |            | 0.06016    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
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 = 332.890104666113, Press = 10.4831186130102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -16005.26    -16005.26   -16095.706   -16095.706    350.03503    350.03503    36190.206    36190.206    1243.8154    1243.8154 
   10000    -16006.69    -16006.69   -16088.639   -16088.639    317.15116    317.15116    36215.664    36215.664    55.634254    55.634254 
Loop time of 108.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.795 ns/day, 30.208 hours/ns, 9.196 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    | 108.18     | 108.18     | 108.18     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082207   | 0.082207   | 0.082207   |   0.0 |  0.08
Output  | 0.00015654 | 0.00015654 | 0.00015654 |   0.0 |  0.00
Modify  | 0.4199     | 0.4199     | 0.4199     |   0.0 |  0.39
Other   |            | 0.0602     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
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 = 332.935237864539, Press = 6.25967520803447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -16006.69    -16006.69   -16088.639   -16088.639    317.15116    317.15116    36215.664    36215.664    55.634254    55.634254 
   11000   -16005.989   -16005.989   -16092.886   -16092.886     336.3016     336.3016    36236.325    36236.325   -1130.6784   -1130.6784 
Loop time of 108.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.025 hours/ns, 9.252 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    | 107.53     | 107.53     | 107.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082235   | 0.082235   | 0.082235   |   0.0 |  0.08
Output  | 0.00015679 | 0.00015679 | 0.00015679 |   0.0 |  0.00
Modify  | 0.41738    | 0.41738    | 0.41738    |   0.0 |  0.39
Other   |            | 0.06019    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115956.0 ave      115956 max      115956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115956
Ave neighs/atom = 57.978000
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 = 333.358062469926, Press = -3.89485110472461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16005.989   -16005.989   -16092.886   -16092.886     336.3016     336.3016    36236.325    36236.325   -1130.6784   -1130.6784 
   12000   -16004.866   -16004.866   -16093.125   -16093.125    341.57007    341.57007    36150.062    36150.062    3432.1957    3432.1957 
Loop time of 106.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.666 hours/ns, 9.363 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    | 106.25     | 106.25     | 106.25     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081306   | 0.081306   | 0.081306   |   0.0 |  0.08
Output  | 0.00019142 | 0.00019142 | 0.00019142 |   0.0 |  0.00
Modify  | 0.41304    | 0.41304    | 0.41304    |   0.0 |  0.39
Other   |            | 0.05972    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.333783669657, Press = 14.3406725407366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16004.866   -16004.866   -16093.125   -16093.125    341.57007    341.57007    36150.062    36150.062    3432.1957    3432.1957 
   13000   -16005.398   -16005.398   -16086.236   -16086.236    312.85171    312.85171    36275.368    36275.368    -2845.773    -2845.773 
Loop time of 105.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.294 hours/ns, 9.482 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    | 104.91     | 104.91     | 104.91     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080964   | 0.080964   | 0.080964   |   0.0 |  0.08
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.40427    | 0.40427    | 0.40427    |   0.0 |  0.38
Other   |            | 0.05951    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.087320333338, Press = -0.42128261937028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16005.398   -16005.398   -16086.236   -16086.236    312.85171    312.85171    36275.368    36275.368    -2845.773    -2845.773 
   14000   -16004.418   -16004.418   -16092.885   -16092.885    342.37498    342.37498    36189.572    36189.572    1447.9758    1447.9758 
Loop time of 104.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.123 hours/ns, 9.538 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    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080751   | 0.080751   | 0.080751   |   0.0 |  0.08
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.40078    | 0.40078    | 0.40078    |   0.0 |  0.38
Other   |            | 0.05822    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115942.0 ave      115942 max      115942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115942
Ave neighs/atom = 57.971000
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 = 333.125228506739, Press = 5.96419767920165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -16004.418   -16004.418   -16092.885   -16092.885    342.37498    342.37498    36189.572    36189.572    1447.9758    1447.9758 
   15000   -16009.799   -16009.799   -16091.329   -16091.329    315.53124    315.53124    36219.117    36219.117   -212.21806   -212.21806 
Loop time of 103.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.714 hours/ns, 9.674 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    | 102.84     | 102.84     | 102.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079295   | 0.079295   | 0.079295   |   0.0 |  0.08
Output  | 0.0001896  | 0.0001896  | 0.0001896  |   0.0 |  0.00
Modify  | 0.39247    | 0.39247    | 0.39247    |   0.0 |  0.38
Other   |            | 0.05831    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.076535059915, Press = 1.73192537950619
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -16009.799   -16009.799   -16091.329   -16091.329    315.53124    315.53124    36219.117    36219.117   -212.21806   -212.21806 
   16000    -16005.23    -16005.23   -16094.321   -16094.321    344.79481    344.79481    36229.637    36229.637   -854.64819   -854.64819 
Loop time of 103.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.622 hours/ns, 9.705 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    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079541   | 0.079541   | 0.079541   |   0.0 |  0.08
Output  | 0.0002168  | 0.0002168  | 0.0002168  |   0.0 |  0.00
Modify  | 0.39046    | 0.39046    | 0.39046    |   0.0 |  0.38
Other   |            | 0.05842    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
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 = 333.046842231621, Press = -0.332723543301965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -16005.23    -16005.23   -16094.321   -16094.321    344.79481    344.79481    36229.637    36229.637   -854.64819   -854.64819 
   17000   -16003.668   -16003.668   -16088.382   -16088.382    327.85325    327.85325    36220.541    36220.541   -13.628449   -13.628449 
Loop time of 104.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.000 hours/ns, 9.579 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    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080488   | 0.080488   | 0.080488   |   0.0 |  0.08
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.39665    | 0.39665    | 0.39665    |   0.0 |  0.38
Other   |            | 0.05839    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
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 = 333.252999443972, Press = 4.80656256332235
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16003.668   -16003.668   -16088.382   -16088.382    327.85325    327.85325    36220.541    36220.541   -13.628449   -13.628449 
   18000   -16006.583   -16006.583   -16088.288   -16088.288    316.20502    316.20502     36185.68     36185.68    1767.6672    1767.6672 
Loop time of 106.176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.493 hours/ns, 9.418 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    | 105.62     | 105.62     | 105.62     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081457   | 0.081457   | 0.081457   |   0.0 |  0.08
Output  | 0.00019181 | 0.00019181 | 0.00019181 |   0.0 |  0.00
Modify  | 0.41068    | 0.41068    | 0.41068    |   0.0 |  0.39
Other   |            | 0.05929    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.223916355696, Press = -1.65891388345056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16006.583   -16006.583   -16088.288   -16088.288    316.20502    316.20502     36185.68     36185.68    1767.6672    1767.6672 
   19000   -16004.942   -16004.942   -16091.662   -16091.662    335.61304    335.61304    36252.036    36252.036   -1864.7952   -1864.7952 
Loop time of 105.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.362 hours/ns, 9.460 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    | 105.16     | 105.16     | 105.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081019   | 0.081019   | 0.081019   |   0.0 |  0.08
Output  | 0.00015717 | 0.00015717 | 0.00015717 |   0.0 |  0.00
Modify  | 0.4064     | 0.4064     | 0.4064     |   0.0 |  0.38
Other   |            | 0.05966    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.361038161101, Press = 1.48063750491154
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -16004.942   -16004.942   -16091.662   -16091.662    335.61304    335.61304    36252.036    36252.036   -1864.7952   -1864.7952 
   20000   -16006.204   -16006.204   -16093.628   -16093.628    338.33975    338.33975    36190.532    36190.532    1274.5361    1274.5361 
Loop time of 102.839 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.566 hours/ns, 9.724 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    | 102.31     | 102.31     | 102.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079159   | 0.079159   | 0.079159   |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.38915    | 0.38915    | 0.38915    |   0.0 |  0.38
Other   |            | 0.05818    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
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 = 333.412010804492, Press = 2.65285479437977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16006.204   -16006.204   -16093.628   -16093.628    338.33975    338.33975    36190.532    36190.532    1274.5361    1274.5361 
   21000   -16004.674   -16004.674   -16091.857   -16091.857    337.40558    337.40558    36219.539    36219.539   -187.57261   -187.57261 
Loop time of 105.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.422 hours/ns, 9.441 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    | 105.37     | 105.37     | 105.37     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081574   | 0.081574   | 0.081574   |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.4084     | 0.4084     | 0.4084     |   0.0 |  0.39
Other   |            | 0.06005    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
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 = 333.434732210377, Press = -0.560492593945884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16004.674   -16004.674   -16091.857   -16091.857    337.40558    337.40558    36219.539    36219.539   -187.57261   -187.57261 
   22000   -16003.007   -16003.007   -16087.722   -16087.722    327.85567    327.85567    36198.504    36198.504     1270.453     1270.453 
Loop time of 104.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.990 hours/ns, 9.582 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    | 103.82     | 103.82     | 103.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081944   | 0.081944   | 0.081944   |   0.0 |  0.08
Output  | 0.00021424 | 0.00021424 | 0.00021424 |   0.0 |  0.00
Modify  | 0.39721    | 0.39721    | 0.39721    |   0.0 |  0.38
Other   |            | 0.05812    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115962.0 ave      115962 max      115962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115962
Ave neighs/atom = 57.981000
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 = 333.419888878491, Press = 0.416522580703072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -16003.007   -16003.007   -16087.722   -16087.722    327.85567    327.85567    36198.504    36198.504     1270.453     1270.453 
   23000   -16007.158   -16007.158   -16093.202   -16093.202    332.99995    332.99995    36248.593    36248.593   -1773.6779   -1773.6779 
Loop time of 109.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.351 hours/ns, 9.152 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    | 108.7      | 108.7      | 108.7      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082748   | 0.082748   | 0.082748   |   0.0 |  0.08
Output  | 0.00019931 | 0.00019931 | 0.00019931 |   0.0 |  0.00
Modify  | 0.42323    | 0.42323    | 0.42323    |   0.0 |  0.39
Other   |            | 0.06044    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.332342684941, Press = 0.661363538066337
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -16007.158   -16007.158   -16093.202   -16093.202    332.99995    332.99995    36248.593    36248.593   -1773.6779   -1773.6779 
   24000   -16001.673   -16001.673   -16085.838   -16085.838    325.72758    325.72758    36223.047    36223.047    150.69615    150.69615 
Loop time of 103.522 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.756 hours/ns, 9.660 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    | 102.99     | 102.99     | 102.99     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078562   | 0.078562   | 0.078562   |   0.0 |  0.08
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.39571    | 0.39571    | 0.39571    |   0.0 |  0.38
Other   |            | 0.05861    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
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 = 333.347087650791, Press = 2.89977015799141
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16001.673   -16001.673   -16085.838   -16085.838    325.72758    325.72758    36223.047    36223.047    150.69615    150.69615 
   25000   -16007.422   -16007.422   -16093.498   -16093.498     333.1245     333.1245     36240.73     36240.73   -1440.7587   -1440.7587 
Loop time of 101.306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.141 hours/ns, 9.871 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    | 100.79     | 100.79     | 100.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077709   | 0.077709   | 0.077709   |   0.0 |  0.08
Output  | 0.00015681 | 0.00015681 | 0.00015681 |   0.0 |  0.00
Modify  | 0.37895    | 0.37895    | 0.37895    |   0.0 |  0.37
Other   |            | 0.05724    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115952.0 ave      115952 max      115952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115952
Ave neighs/atom = 57.976000
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 = 333.455185764656, Press = -0.700947734473957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16007.422   -16007.422   -16093.498   -16093.498     333.1245     333.1245     36240.73     36240.73   -1440.7587   -1440.7587 
   26000   -16004.809   -16004.809   -16090.268   -16090.268    330.73431    330.73431     36173.99     36173.99     2348.949     2348.949 
Loop time of 99.6006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.667 hours/ns, 10.040 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    | 99.096     | 99.096     | 99.096     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076827   | 0.076827   | 0.076827   |   0.0 |  0.08
Output  | 0.00015807 | 0.00015807 | 0.00015807 |   0.0 |  0.00
Modify  | 0.37156    | 0.37156    | 0.37156    |   0.0 |  0.37
Other   |            | 0.05622    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
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 = 333.536225889095, Press = 2.73856796350482
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16004.809   -16004.809   -16090.268   -16090.268    330.73431    330.73431     36173.99     36173.99     2348.949     2348.949 
   27000   -16000.639   -16000.639   -16087.114   -16087.114    334.66656    334.66656    36248.405    36248.405   -1152.8668   -1152.8668 
Loop time of 100.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.031 hours/ns, 9.910 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    | 100.4      | 100.4      | 100.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077183   | 0.077183   | 0.077183   |   0.0 |  0.08
Output  | 0.00015767 | 0.00015767 | 0.00015767 |   0.0 |  0.00
Modify  | 0.37795    | 0.37795    | 0.37795    |   0.0 |  0.37
Other   |            | 0.05743    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
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 = 333.574773564288, Press = -0.562540753475975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -16000.639   -16000.639   -16087.114   -16087.114    334.66656    334.66656    36248.405    36248.405   -1152.8668   -1152.8668 
   28000   -16007.155   -16007.155   -16093.842   -16093.842    335.48776    335.48776    36192.957    36192.957    1062.8278    1062.8278 
Loop time of 105.203 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.223 hours/ns, 9.505 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    | 104.66     | 104.66     | 104.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080344   | 0.080344   | 0.080344   |   0.0 |  0.08
Output  | 0.00015529 | 0.00015529 | 0.00015529 |   0.0 |  0.00
Modify  | 0.39943    | 0.39943    | 0.39943    |   0.0 |  0.38
Other   |            | 0.05868    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115952.0 ave      115952 max      115952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115952
Ave neighs/atom = 57.976000
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 = 333.575945683908, Press = 1.48623129411793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -16007.155   -16007.155   -16093.842   -16093.842    335.48776    335.48776    36192.957    36192.957    1062.8278    1062.8278 
   29000    -16007.23    -16007.23   -16092.253   -16092.253    329.04668    329.04668    36240.059    36240.059   -1345.6522   -1345.6522 
Loop time of 108.59 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.796 ns/day, 30.164 hours/ns, 9.209 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    | 108.02     | 108.02     | 108.02     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083219   | 0.083219   | 0.083219   |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.42168    | 0.42168    | 0.42168    |   0.0 |  0.39
Other   |            | 0.06059    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.42185547863, Press = 0.12392209813826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -16007.23    -16007.23   -16092.253   -16092.253    329.04668    329.04668    36240.059    36240.059   -1345.6522   -1345.6522 
   30000   -16000.496   -16000.496   -16090.401   -16090.401    347.94148    347.94148     36244.96     36244.96   -1175.2744   -1175.2744 
Loop time of 102.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.434 hours/ns, 9.769 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    | 101.84     | 101.84     | 101.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078267   | 0.078267   | 0.078267   |   0.0 |  0.08
Output  | 0.00045023 | 0.00045023 | 0.00045023 |   0.0 |  0.00
Modify  | 0.38567    | 0.38567    | 0.38567    |   0.0 |  0.38
Other   |            | 0.05802    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.484559384023, Press = 2.60214577018107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -16000.496   -16000.496   -16090.401   -16090.401    347.94148    347.94148     36244.96     36244.96   -1175.2744   -1175.2744 
   31000   -16007.777   -16007.777   -16092.432   -16092.432    327.62216    327.62216    36208.069    36208.069     396.3315     396.3315 
Loop time of 104.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.019 hours/ns, 9.572 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    | 103.93     | 103.93     | 103.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080374   | 0.080374   | 0.080374   |   0.0 |  0.08
Output  | 0.00015259 | 0.00015259 | 0.00015259 |   0.0 |  0.00
Modify  | 0.39643    | 0.39643    | 0.39643    |   0.0 |  0.38
Other   |            | 0.05829    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 333.510899265943, Press = -0.527158596779764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -16007.777   -16007.777   -16092.432   -16092.432    327.62216    327.62216    36208.069    36208.069     396.3315     396.3315 
   32000   -16009.174   -16009.174   -16093.241   -16093.241    325.35049    325.35049    36228.101    36228.101    -814.3996    -814.3996 
Loop time of 104.665 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.074 hours/ns, 9.554 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    | 104.13     | 104.13     | 104.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080771   | 0.080771   | 0.080771   |   0.0 |  0.08
Output  | 0.0001581  | 0.0001581  | 0.0001581  |   0.0 |  0.00
Modify  | 0.39553    | 0.39553    | 0.39553    |   0.0 |  0.38
Other   |            | 0.05885    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.53335437751, Press = 2.624152801889
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -16009.174   -16009.174   -16093.241   -16093.241    325.35049    325.35049    36228.101    36228.101    -814.3996    -814.3996 
   33000   -16002.025   -16002.025   -16090.276   -16090.276     341.5389     341.5389    36230.247    36230.247    -536.4008    -536.4008 
Loop time of 105.432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.287 hours/ns, 9.485 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    | 104.89     | 104.89     | 104.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081097   | 0.081097   | 0.081097   |   0.0 |  0.08
Output  | 0.00020379 | 0.00020379 | 0.00020379 |   0.0 |  0.00
Modify  | 0.40388    | 0.40388    | 0.40388    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
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 = 333.576308540737, Press = -0.505462443920408
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16002.025   -16002.025   -16090.276   -16090.276     341.5389     341.5389    36230.247    36230.247    -536.4008    -536.4008 
   34000   -16005.966   -16005.966   -16094.901   -16094.901    344.18409    344.18409    36202.162    36202.162    627.89177    627.89177 
Loop time of 104.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.132 hours/ns, 9.535 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    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079814   | 0.079814   | 0.079814   |   0.0 |  0.08
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.39903    | 0.39903    | 0.39903    |   0.0 |  0.38
Other   |            | 0.05898    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.577623971573, Press = 1.83540227574319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16005.966   -16005.966   -16094.901   -16094.901    344.18409    344.18409    36202.162    36202.162    627.89177    627.89177 
   35000   -16003.828   -16003.828   -16093.685   -16093.685    347.75739    347.75739     36213.75     36213.75    158.49961    158.49961 
Loop time of 106.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.671 hours/ns, 9.362 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    | 106.27     | 106.27     | 106.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08133    | 0.08133    | 0.08133    |   0.0 |  0.08
Output  | 0.00022139 | 0.00022139 | 0.00022139 |   0.0 |  0.00
Modify  | 0.40826    | 0.40826    | 0.40826    |   0.0 |  0.38
Other   |            | 0.05968    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
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 = 333.604618782521, Press = -2.71283325254476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -16003.828   -16003.828   -16093.685   -16093.685    347.75739    347.75739     36213.75     36213.75    158.49961    158.49961 
   36000   -16007.388   -16007.388   -16092.444   -16092.444    329.17455    329.17455    36228.468    36228.468   -712.28485   -712.28485 
Loop time of 103.139 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.650 hours/ns, 9.696 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    | 102.61     | 102.61     | 102.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079044   | 0.079044   | 0.079044   |   0.0 |  0.08
Output  | 0.00020518 | 0.00020518 | 0.00020518 |   0.0 |  0.00
Modify  | 0.3909     | 0.3909     | 0.3909     |   0.0 |  0.38
Other   |            | 0.05807    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
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 = 333.525687283186, Press = 3.15285122221579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -16007.388   -16007.388   -16092.444   -16092.444    329.17455    329.17455    36228.468    36228.468   -712.28485   -712.28485 
   37000   -16005.836   -16005.836   -16094.009   -16094.009    341.23804    341.23804    36202.773    36202.773      508.508      508.508 
Loop time of 103.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.639 hours/ns, 9.699 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    | 102.57     | 102.57     | 102.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079272   | 0.079272   | 0.079272   |   0.0 |  0.08
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.3914     | 0.3914     | 0.3914     |   0.0 |  0.38
Other   |            | 0.05753    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
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 = 333.520232056039, Press = -0.365939999099277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -16005.836   -16005.836   -16094.009   -16094.009    341.23804    341.23804    36202.773    36202.773      508.508      508.508 
   38000   -16006.991   -16006.991   -16089.923   -16089.923     320.9562     320.9562    36219.778    36219.778   -26.355536   -26.355536 
Loop time of 102.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.430 hours/ns, 9.771 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    | 101.82     | 101.82     | 101.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079133   | 0.079133   | 0.079133   |   0.0 |  0.08
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.39041    | 0.39041    | 0.39041    |   0.0 |  0.38
Other   |            | 0.05847    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
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 = 333.447137378231, Press = 2.10905771817928
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -16006.991   -16006.991   -16089.923   -16089.923     320.9562     320.9562    36219.778    36219.778   -26.355536   -26.355536 
   39000    -16003.77    -16003.77   -16091.445   -16091.445    339.31119    339.31119    36184.913    36184.913    1808.2464    1808.2464 
Loop time of 103.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.752 hours/ns, 9.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    | 102.97     | 102.97     | 102.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079589   | 0.079589   | 0.079589   |   0.0 |  0.08
Output  | 0.00020017 | 0.00020017 | 0.00020017 |   0.0 |  0.00
Modify  | 0.39379    | 0.39379    | 0.39379    |   0.0 |  0.38
Other   |            | 0.05863    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.52614247869, Press = -0.819110365976209
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -16003.77    -16003.77   -16091.445   -16091.445    339.31119    339.31119    36184.913    36184.913    1808.2464    1808.2464 
   40000   -16006.269   -16006.269   -16091.675   -16091.675     330.5318     330.5318    36229.613    36229.613   -588.54947   -588.54947 
Loop time of 105.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.292 hours/ns, 9.483 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    | 104.91     | 104.91     | 104.91     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080957   | 0.080957   | 0.080957   |   0.0 |  0.08
Output  | 0.00015318 | 0.00015318 | 0.00015318 |   0.0 |  0.00
Modify  | 0.40339    | 0.40339    | 0.40339    |   0.0 |  0.38
Other   |            | 0.05956    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
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 = 333.545522110504, Press = 0.9817918612961
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -16006.269   -16006.269   -16091.675   -16091.675     330.5318     330.5318    36229.613    36229.613   -588.54947   -588.54947 
   41000   -16004.913   -16004.913   -16093.077   -16093.077    341.20284    341.20284    36231.498    36231.498   -851.14703   -851.14703 
Loop time of 108.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.793 ns/day, 30.263 hours/ns, 9.179 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    | 108.38     | 108.38     | 108.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082922   | 0.082922   | 0.082922   |   0.0 |  0.08
Output  | 0.00028506 | 0.00028506 | 0.00028506 |   0.0 |  0.00
Modify  | 0.42235    | 0.42235    | 0.42235    |   0.0 |  0.39
Other   |            | 0.06058    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115962.0 ave      115962 max      115962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115962
Ave neighs/atom = 57.981000
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 = 333.526589444429, Press = 0.00909125170334522
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -16004.913   -16004.913   -16093.077   -16093.077    341.20284    341.20284    36231.498    36231.498   -851.14703   -851.14703 
   42000   -16006.369   -16006.369   -16093.213   -16093.213    336.09318    336.09318    36202.398    36202.398    593.66684    593.66684 
Loop time of 106.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.505 hours/ns, 9.415 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    | 105.67     | 105.67     | 105.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081889   | 0.081889   | 0.081889   |   0.0 |  0.08
Output  | 0.00019167 | 0.00019167 | 0.00019167 |   0.0 |  0.00
Modify  | 0.40736    | 0.40736    | 0.40736    |   0.0 |  0.38
Other   |            | 0.05963    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 333.5338715103, Press = 1.23824790638116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -16006.369   -16006.369   -16093.213   -16093.213    336.09318    336.09318    36202.398    36202.398    593.66684    593.66684 
   43000     -16006.6     -16006.6   -16093.363   -16093.363    335.78292    335.78292     36218.25     36218.25   -230.02256   -230.02256 
Loop time of 97.9614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.211 hours/ns, 10.208 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    | 97.462     | 97.462     | 97.462     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076316   | 0.076316   | 0.076316   |   0.0 |  0.08
Output  | 0.00018847 | 0.00018847 | 0.00018847 |   0.0 |  0.00
Modify  | 0.36714    | 0.36714    | 0.36714    |   0.0 |  0.37
Other   |            | 0.05617    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
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 = 333.562292715733, Press = -0.267775205730728
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000     -16006.6     -16006.6   -16093.363   -16093.363    335.78292    335.78292     36218.25     36218.25   -230.02256   -230.02256 
   44000    -16003.78    -16003.78   -16091.422   -16091.422    339.18388    339.18388    36217.182    36217.182     43.70204     43.70204 
Loop time of 109.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.537 hours/ns, 9.097 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    | 109.36     | 109.36     | 109.36     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084257   | 0.084257   | 0.084257   |   0.0 |  0.08
Output  | 0.00025689 | 0.00025689 | 0.00025689 |   0.0 |  0.00
Modify  | 0.42329    | 0.42329    | 0.42329    |   0.0 |  0.39
Other   |            | 0.0613     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
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 = 333.553741698628, Press = 1.31745529775004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -16003.78    -16003.78   -16091.422   -16091.422    339.18388    339.18388    36217.182    36217.182     43.70204     43.70204 
   45000   -16007.404   -16007.404   -16093.657   -16093.657    333.80826    333.80826     36182.05     36182.05    1647.5572    1647.5572 
Loop time of 102.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.395 hours/ns, 9.783 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    | 101.69     | 101.69     | 101.69     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079033   | 0.079033   | 0.079033   |   0.0 |  0.08
Output  | 0.00015409 | 0.00015409 | 0.00015409 |   0.0 |  0.00
Modify  | 0.39196    | 0.39196    | 0.39196    |   0.0 |  0.38
Other   |            | 0.05791    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.517856115674, Press = -0.78263065912605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -16007.404   -16007.404   -16093.657   -16093.657    333.80826    333.80826     36182.05     36182.05    1647.5572    1647.5572 
   46000   -16003.471   -16003.471   -16089.846   -16089.846    334.28147    334.28147    36251.356    36251.356   -1579.2853   -1579.2853 
Loop time of 104.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.901 hours/ns, 9.611 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    | 103.51     | 103.51     | 103.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08102    | 0.08102    | 0.08102    |   0.0 |  0.08
Output  | 0.00019756 | 0.00019756 | 0.00019756 |   0.0 |  0.00
Modify  | 0.39782    | 0.39782    | 0.39782    |   0.0 |  0.38
Other   |            | 0.05923    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
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 = 333.563395237228, Press = 1.72971524612713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -16003.471   -16003.471   -16089.846   -16089.846    334.28147    334.28147    36251.356    36251.356   -1579.2853   -1579.2853 
   47000   -16005.824   -16005.824   -16091.623   -16091.623    332.04988    332.04988    36168.972    36168.972    2408.5911    2408.5911 
Loop time of 106.215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.504 hours/ns, 9.415 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    | 105.66     | 105.66     | 105.66     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082155   | 0.082155   | 0.082155   |   0.0 |  0.08
Output  | 0.00020221 | 0.00020221 | 0.00020221 |   0.0 |  0.00
Modify  | 0.4098     | 0.4098     | 0.4098     |   0.0 |  0.39
Other   |            | 0.05992    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.54497165764, Press = -0.296470500830061
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -16005.824   -16005.824   -16091.623   -16091.623    332.04988    332.04988    36168.972    36168.972    2408.5911    2408.5911 
   48000   -15999.004   -15999.004   -16089.656   -16089.656    350.83179    350.83179    36235.956    36235.956   -638.59995   -638.59995 
Loop time of 99.4549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.626 hours/ns, 10.055 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    | 98.945     | 98.945     | 98.945     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077668   | 0.077668   | 0.077668   |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.37497    | 0.37497    | 0.37497    |   0.0 |  0.38
Other   |            | 0.05698    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
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 = 333.613421341999, Press = 0.600334895475866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -15999.004   -15999.004   -16089.656   -16089.656    350.83179    350.83179    36235.956    36235.956   -638.59995   -638.59995 
   49000   -16006.476   -16006.476   -16093.568   -16093.568     337.0549     337.0549    36213.886    36213.886   -108.55501   -108.55501 
Loop time of 104.751 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.097 hours/ns, 9.546 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    | 104.21     | 104.21     | 104.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080806   | 0.080806   | 0.080806   |   0.0 |  0.08
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.39817    | 0.39817    | 0.39817    |   0.0 |  0.38
Other   |            | 0.05882    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115962.0 ave      115962 max      115962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115962
Ave neighs/atom = 57.981000
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 = 333.665471810139, Press = 0.31913541651804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -16006.476   -16006.476   -16093.568   -16093.568     337.0549     337.0549    36213.886    36213.886   -108.55501   -108.55501 
   50000   -16002.393   -16002.393   -16088.738   -16088.738    334.16614    334.16614    36240.201    36240.201   -1033.3364   -1033.3364 
Loop time of 107.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.812 hours/ns, 9.318 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    | 106.77     | 106.77     | 106.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082481   | 0.082481   | 0.082481   |   0.0 |  0.08
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.41527    | 0.41527    | 0.41527    |   0.0 |  0.39
Other   |            | 0.0598     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
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 = 333.666994447093, Press = 0.51346710585867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -16002.393   -16002.393   -16088.738   -16088.738    334.16614    334.16614    36240.201    36240.201   -1033.3364   -1033.3364 
   51000   -16007.778   -16007.778   -16091.904   -16091.904    325.57632    325.57632    36113.089    36113.089    5405.2599    5405.2599 
Loop time of 108.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.796 ns/day, 30.151 hours/ns, 9.213 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    | 107.98     | 107.98     | 107.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083414   | 0.083414   | 0.083414   |   0.0 |  0.08
Output  | 0.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.42155    | 0.42155    | 0.42155    |   0.0 |  0.39
Other   |            | 0.05998    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115958.0 ave      115958 max      115958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115958
Ave neighs/atom = 57.979000
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 = 333.673112783352, Press = 0.70940694147599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -16007.778   -16007.778   -16091.904   -16091.904    325.57632    325.57632    36113.089    36113.089    5405.2599    5405.2599 
   52000   -16004.988   -16004.988   -16090.752   -16090.752    331.91602    331.91602    36278.949    36278.949   -3350.9888   -3350.9888 
Loop time of 103.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.793 hours/ns, 9.647 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    | 103.12     | 103.12     | 103.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079667   | 0.079667   | 0.079667   |   0.0 |  0.08
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.3914     | 0.3914     | 0.3914     |   0.0 |  0.38
Other   |            | 0.05852    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115962.0 ave      115962 max      115962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115962
Ave neighs/atom = 57.981000
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 = 333.675710718826, Press = -0.0510346076531237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -16004.988   -16004.988   -16090.752   -16090.752    331.91602    331.91602    36278.949    36278.949   -3350.9888   -3350.9888 
   53000   -16009.992   -16009.992   -16094.831   -16094.831    328.33731    328.33731    36148.226    36148.226    3386.1427    3386.1427 
Loop time of 101.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.852 ns/day, 28.184 hours/ns, 9.856 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    | 100.94     | 100.94     | 100.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078724   | 0.078724   | 0.078724   |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.38366    | 0.38366    | 0.38366    |   0.0 |  0.38
Other   |            | 0.05752    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115954.0 ave      115954 max      115954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115954
Ave neighs/atom = 57.977000
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 = 333.638010084797, Press = 0.684770437281592
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -16009.992   -16009.992   -16094.831   -16094.831    328.33731    328.33731    36148.226    36148.226    3386.1427    3386.1427 
   54000   -16004.465   -16004.465   -16090.879   -16090.879     334.4323     334.4323    36272.128    36272.128   -2868.3041   -2868.3041 
Loop time of 100.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.892 hours/ns, 9.959 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    | 99.899     | 99.899     | 99.899     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077484   | 0.077484   | 0.077484   |   0.0 |  0.08
Output  | 0.00022067 | 0.00022067 | 0.00022067 |   0.0 |  0.00
Modify  | 0.37757    | 0.37757    | 0.37757    |   0.0 |  0.38
Other   |            | 0.05724    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
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 = 333.578706242785, Press = 0.0855781017564941
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -16004.465   -16004.465   -16090.879   -16090.879     334.4323     334.4323    36272.128    36272.128   -2868.3041   -2868.3041 
   55000   -16009.525   -16009.525   -16094.064   -16094.064    327.17439    327.17439    36164.919    36164.919    2491.1511    2491.1511 
Loop time of 106.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.552 hours/ns, 9.400 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    | 105.84     | 105.84     | 105.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082375   | 0.082375   | 0.082375   |   0.0 |  0.08
Output  | 0.00024692 | 0.00024692 | 0.00024692 |   0.0 |  0.00
Modify  | 0.41008    | 0.41008    | 0.41008    |   0.0 |  0.39
Other   |            | 0.05906    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115952.0 ave      115952 max      115952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115952
Ave neighs/atom = 57.976000
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 = 333.533515881053, Press = 0.740909041916719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -16009.525   -16009.525   -16094.064   -16094.064    327.17439    327.17439    36164.919    36164.919    2491.1511    2491.1511 
   56000   -16003.935   -16003.935   -16087.743   -16087.743    324.34543    324.34543     36242.36     36242.36   -1012.3982   -1012.3982 
Loop time of 105.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.255 hours/ns, 9.495 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    | 104.77     | 104.77     | 104.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080863   | 0.080863   | 0.080863   |   0.0 |  0.08
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.40341    | 0.40341    | 0.40341    |   0.0 |  0.38
Other   |            | 0.05938    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
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 = 333.515049297401, Press = 0.30637047586706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -16003.935   -16003.935   -16087.743   -16087.743    324.34543    324.34543     36242.36     36242.36   -1012.3982   -1012.3982 
   57000   -16008.932   -16008.932   -16093.543   -16093.543    327.45459    327.45459    36210.428    36210.428    36.419747    36.419747 
Loop time of 102.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.368 hours/ns, 9.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    | 101.6      | 101.6      | 101.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078485   | 0.078485   | 0.078485   |   0.0 |  0.08
Output  | 0.0001544  | 0.0001544  | 0.0001544  |   0.0 |  0.00
Modify  | 0.38636    | 0.38636    | 0.38636    |   0.0 |  0.38
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115942.0 ave      115942 max      115942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115942
Ave neighs/atom = 57.971000
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 = 333.495493121286, Press = 0.435273536293439
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -16008.932   -16008.932   -16093.543   -16093.543    327.45459    327.45459    36210.428    36210.428    36.419747    36.419747 
   58000   -16007.468   -16007.468   -16090.836   -16090.836    322.64528    322.64528    36235.588    36235.588   -926.80905   -926.80905 
Loop time of 105.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.285 hours/ns, 9.485 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    | 104.89     | 104.89     | 104.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080325   | 0.080325   | 0.080325   |   0.0 |  0.08
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 0.4017     | 0.4017     | 0.4017     |   0.0 |  0.38
Other   |            | 0.05893    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
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 = 333.437207228913, Press = 0.62827910443575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -16007.468   -16007.468   -16090.836   -16090.836    322.64528    322.64528    36235.588    36235.588   -926.80905   -926.80905 
   59000   -16002.966   -16002.966   -16088.532   -16088.532    331.14834    331.14834    36114.652    36114.652    5548.0161    5548.0161 
Loop time of 104.783 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.106 hours/ns, 9.544 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    | 104.25     | 104.25     | 104.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079899   | 0.079899   | 0.079899   |   0.0 |  0.08
Output  | 0.00015168 | 0.00015168 | 0.00015168 |   0.0 |  0.00
Modify  | 0.39739    | 0.39739    | 0.39739    |   0.0 |  0.38
Other   |            | 0.05804    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115956.0 ave      115956 max      115956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115956
Ave neighs/atom = 57.978000
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 = 333.410242298755, Press = 0.322867614934228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -16002.966   -16002.966   -16088.532   -16088.532    331.14834    331.14834    36114.652    36114.652    5548.0161    5548.0161 
   60000   -16007.707   -16007.707   -16093.788   -16093.788     333.1413     333.1413    36293.828    36293.828   -4204.8754   -4204.8754 
Loop time of 103.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.784 hours/ns, 9.651 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    | 103.09     | 103.09     | 103.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079788   | 0.079788   | 0.079788   |   0.0 |  0.08
Output  | 0.00015381 | 0.00015381 | 0.00015381 |   0.0 |  0.00
Modify  | 0.39369    | 0.39369    | 0.39369    |   0.0 |  0.38
Other   |            | 0.05882    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 333.411433028101, Press = 0.160085317840649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -16007.707   -16007.707   -16093.788   -16093.788     333.1413     333.1413    36293.828    36293.828   -4204.8754   -4204.8754 
   61000   -16002.468   -16002.468   -16088.519   -16088.519    333.02608    333.02608    36177.789    36177.789    2362.0784    2362.0784 
Loop time of 104.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.154 hours/ns, 9.528 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    | 104.42     | 104.42     | 104.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079939   | 0.079939   | 0.079939   |   0.0 |  0.08
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.39695    | 0.39695    | 0.39695    |   0.0 |  0.38
Other   |            | 0.05884    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115962.0 ave      115962 max      115962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115962
Ave neighs/atom = 57.981000
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 = 333.420408826087, Press = 0.929437492063823
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -16002.468   -16002.468   -16088.519   -16088.519    333.02608    333.02608    36177.789    36177.789    2362.0784    2362.0784 
   62000   -16003.079   -16003.079   -16090.417   -16090.417    338.00667    338.00667    36252.928    36252.928   -1844.9729   -1844.9729 
Loop time of 104.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.901 hours/ns, 9.611 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    | 103.51     | 103.51     | 103.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079854   | 0.079854   | 0.079854   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.3952     | 0.3952     | 0.3952     |   0.0 |  0.38
Other   |            | 0.05891    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
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 = 333.420041569783, Press = -0.0101517002319645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -16003.079   -16003.079   -16090.417   -16090.417    338.00667    338.00667    36252.928    36252.928   -1844.9729   -1844.9729 
   63000    -16006.81    -16006.81   -16093.152   -16093.152    334.15563    334.15563    36226.758    36226.758   -739.29471   -739.29471 
Loop time of 102.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.415 hours/ns, 9.776 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    | 101.77     | 101.77     | 101.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079664   | 0.079664   | 0.079664   |   0.0 |  0.08
Output  | 0.00020091 | 0.00020091 | 0.00020091 |   0.0 |  0.00
Modify  | 0.38894    | 0.38894    | 0.38894    |   0.0 |  0.38
Other   |            | 0.05825    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115946.0 ave      115946 max      115946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115946
Ave neighs/atom = 57.973000
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 = 333.475545214831, Press = 0.959592667695699
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -16006.81    -16006.81   -16093.152   -16093.152    334.15563    334.15563    36226.758    36226.758   -739.29471   -739.29471 
   64000   -16004.942   -16004.942   -16088.167   -16088.167    322.08813    322.08813    36206.411    36206.411    738.68995    738.68995 
Loop time of 101.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.290 hours/ns, 9.819 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    | 101.32     | 101.32     | 101.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078931   | 0.078931   | 0.078931   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.38645    | 0.38645    | 0.38645    |   0.0 |  0.38
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
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 = 333.446014182989, Press = 0.430761109183841
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -16004.942   -16004.942   -16088.167   -16088.167    322.08813    322.08813    36206.411    36206.411    738.68995    738.68995 
   65000   -16003.305   -16003.305   -16091.024   -16091.024    339.48493    339.48493    36222.171    36222.171   -176.27913   -176.27913 
Loop time of 105.192 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.220 hours/ns, 9.506 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    | 104.65     | 104.65     | 104.65     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080696   | 0.080696   | 0.080696   |   0.0 |  0.08
Output  | 0.00019538 | 0.00019538 | 0.00019538 |   0.0 |  0.00
Modify  | 0.40334    | 0.40334    | 0.40334    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
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 = 333.425255460129, Press = 0.541331775921847
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -16003.305   -16003.305   -16091.024   -16091.024    339.48493    339.48493    36222.171    36222.171   -176.27913   -176.27913 
   66000   -16005.388   -16005.388   -16092.131   -16092.131    335.70604    335.70604    36218.274    36218.274   -140.81768   -140.81768 
Loop time of 104.729 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.091 hours/ns, 9.548 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    | 104.19     | 104.19     | 104.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080994   | 0.080994   | 0.080994   |   0.0 |  0.08
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.39522    | 0.39522    | 0.39522    |   0.0 |  0.38
Other   |            | 0.05848    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115960.0 ave      115960 max      115960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115960
Ave neighs/atom = 57.980000
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 = 333.421532035798, Press = 0.31893369596669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -16005.388   -16005.388   -16092.131   -16092.131    335.70604    335.70604    36218.274    36218.274   -140.81768   -140.81768 
   67000   -16010.126   -16010.126   -16094.181   -16094.181    325.30019    325.30019    36206.433    36206.433    172.07248    172.07248 
Loop time of 97.9228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.201 hours/ns, 10.212 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    | 97.424     | 97.424     | 97.424     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0767     | 0.0767     | 0.0767     |   0.0 |  0.08
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.36565    | 0.36565    | 0.36565    |   0.0 |  0.37
Other   |            | 0.05624    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115964.0 ave      115964 max      115964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115964
Ave neighs/atom = 57.982000
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 = 333.430578226739, Press = 1.00930812710626
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -16010.126   -16010.126   -16094.181   -16094.181    325.30019    325.30019    36206.433    36206.433    172.07248    172.07248 
   68000   -16004.541   -16004.541   -16092.528   -16092.528    340.51882    340.51882    36216.145    36216.145   -29.036116   -29.036116 
Loop time of 106.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.492 hours/ns, 9.419 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    | 105.62     | 105.62     | 105.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082058   | 0.082058   | 0.082058   |   0.0 |  0.08
Output  | 0.00022525 | 0.00022525 | 0.00022525 |   0.0 |  0.00
Modify  | 0.40463    | 0.40463    | 0.40463    |   0.0 |  0.38
Other   |            | 0.05889    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
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 = 333.383415415406, Press = -0.595182806749374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -16004.541   -16004.541   -16092.528   -16092.528    340.51882    340.51882    36216.145    36216.145   -29.036116   -29.036116 
   69000   -16008.973   -16008.973   -16095.309   -16095.309     334.1274     334.1274    36222.099    36222.099   -639.20503   -639.20503 
Loop time of 105.86 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.406 hours/ns, 9.446 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    | 105.31     | 105.31     | 105.31     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082254   | 0.082254   | 0.082254   |   0.0 |  0.08
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.40627    | 0.40627    | 0.40627    |   0.0 |  0.38
Other   |            | 0.05905    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
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 = 333.35301043831, Press = 1.07952479409501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -16008.973   -16008.973   -16095.309   -16095.309     334.1274     334.1274    36222.099    36222.099   -639.20503   -639.20503 
   70000   -16005.206   -16005.206   -16091.034   -16091.034    332.16425    332.16425     36200.69     36200.69    905.83137    905.83137 
Loop time of 106.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.557 hours/ns, 9.398 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    | 105.86     | 105.86     | 105.86     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081296   | 0.081296   | 0.081296   |   0.0 |  0.08
Output  | 0.00015933 | 0.00015933 | 0.00015933 |   0.0 |  0.00
Modify  | 0.40919    | 0.40919    | 0.40919    |   0.0 |  0.38
Other   |            | 0.05953    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
36216.6839981584

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0