# 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.002 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimJungLee_2010_FeNbC__MO_072689718616_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

# 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 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14859.085   -14859.085       -14940       -14940       313.15       313.15     36016.89     36016.89    2399.6435    2399.6435 
    1000   -14776.173   -14776.173   -14862.503   -14862.503    334.10581    334.10581    36183.223    36183.223    914.80464    914.80464 
Loop time of 118.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.934 hours/ns, 8.434 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    | 118.07     | 118.07     | 118.07     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076921   | 0.076921   | 0.076921   |   0.0 |  0.06
Output  | 0.00019034 | 0.00019034 | 0.00019034 |   0.0 |  0.00
Modify  | 0.35664    | 0.35664    | 0.35664    |   0.0 |  0.30
Other   |            | 0.05693    |            |       |  0.05

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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.173   -14776.173   -14862.503   -14862.503    334.10581    334.10581    36183.223    36183.223    914.80464    914.80464 
    2000   -14774.628   -14774.628    -14851.91    -14851.91    299.09291    299.09291    36225.328    36225.328   -582.60565   -582.60565 
Loop time of 134.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.228 hours/ns, 7.462 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    | 133.49     | 133.49     | 133.49     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087305   | 0.087305   | 0.087305   |   0.0 |  0.07
Output  | 0.00023832 | 0.00023832 | 0.00023832 |   0.0 |  0.00
Modify  | 0.37682    | 0.37682    | 0.37682    |   0.0 |  0.28
Other   |            | 0.05979    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3375.00 ave        3375 max        3375 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:      121034.0 ave      121034 max      121034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121034
Ave neighs/atom = 60.517000
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.628   -14774.628    -14851.91    -14851.91    299.09291    299.09291    36225.328    36225.328   -582.60565   -582.60565 
    3000   -14778.295   -14778.295   -14858.233   -14858.233    309.36848    309.36848    36218.181    36218.181   -852.28142   -852.28142 
Loop time of 131.521 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.534 hours/ns, 7.603 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    | 131.01     | 131.01     | 131.01     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084868   | 0.084868   | 0.084868   |   0.0 |  0.06
Output  | 0.00018796 | 0.00018796 | 0.00018796 |   0.0 |  0.00
Modify  | 0.36557    | 0.36557    | 0.36557    |   0.0 |  0.28
Other   |            | 0.0591     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 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:      120914.0 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.457000
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14778.295   -14778.295   -14858.233   -14858.233    309.36848    309.36848    36218.181    36218.181   -852.28142   -852.28142 
    4000   -14773.893   -14773.893   -14855.658   -14855.658    316.43701    316.43701    36228.463    36228.463   -963.53976   -963.53976 
Loop time of 131.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.491 hours/ns, 7.612 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    | 130.86     | 130.86     | 130.86     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084232   | 0.084232   | 0.084232   |   0.0 |  0.06
Output  | 0.00019119 | 0.00019119 | 0.00019119 |   0.0 |  0.00
Modify  | 0.35962    | 0.35962    | 0.35962    |   0.0 |  0.27
Other   |            | 0.05871    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3348.00 ave        3348 max        3348 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:      120970.0 ave      120970 max      120970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120970
Ave neighs/atom = 60.485000
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14773.893   -14773.893   -14855.658   -14855.658    316.43701    316.43701    36228.463    36228.463   -963.53976   -963.53976 
    5000   -14777.956   -14777.956   -14857.781   -14857.781    308.93108    308.93108    36215.993    36215.993   -620.00985   -620.00985 
Loop time of 132.923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.923 hours/ns, 7.523 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    | 132.4      | 132.4      | 132.4      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086845   | 0.086845   | 0.086845   |   0.0 |  0.07
Output  | 0.0001859  | 0.0001859  | 0.0001859  |   0.0 |  0.00
Modify  | 0.3736     | 0.3736     | 0.3736     |   0.0 |  0.28
Other   |            | 0.05946    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3349.00 ave        3349 max        3349 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:      120892.0 ave      120892 max      120892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120892
Ave neighs/atom = 60.446000
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 = 310.247361736189, Press = 462.973144776694
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.956   -14777.956   -14857.781   -14857.781    308.93108    308.93108    36215.993    36215.993   -620.00985   -620.00985 
    6000   -14772.959   -14772.959   -14854.255   -14854.255     314.6226     314.6226     36178.05     36178.05    1687.8666    1687.8666 
Loop time of 132.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.732 hours/ns, 7.562 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    | 131.71     | 131.71     | 131.71     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085246   | 0.085246   | 0.085246   |   0.0 |  0.06
Output  | 0.00015305 | 0.00015305 | 0.00015305 |   0.0 |  0.00
Modify  | 0.38334    | 0.38334    | 0.38334    |   0.0 |  0.29
Other   |            | 0.05932    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3352.00 ave        3352 max        3352 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:      120974.0 ave      120974 max      120974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120974
Ave neighs/atom = 60.487000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.97473866974, Press = 51.9777364553537
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14772.959   -14772.959   -14854.255   -14854.255     314.6226     314.6226     36178.05     36178.05    1687.8666    1687.8666 
    7000   -14777.056   -14777.056   -14858.757   -14858.757    316.19381    316.19381    36155.977    36155.977    2657.1614    2657.1614 
Loop time of 131.64 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.567 hours/ns, 7.596 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    | 131.1      | 131.1      | 131.1      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08773    | 0.08773    | 0.08773    |   0.0 |  0.07
Output  | 0.00015616 | 0.00015616 | 0.00015616 |   0.0 |  0.00
Modify  | 0.38821    | 0.38821    | 0.38821    |   0.0 |  0.29
Other   |            | 0.05922    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3396.00 ave        3396 max        3396 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:      121138.0 ave      121138 max      121138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121138
Ave neighs/atom = 60.569000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.168697665313, Press = -3.79602982712903
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.056   -14777.056   -14858.757   -14858.757    316.19381    316.19381    36155.977    36155.977    2657.1614    2657.1614 
    8000   -14772.803   -14772.803   -14857.804   -14857.804    328.96082    328.96082    36210.679    36210.679   -181.75267   -181.75267 
Loop time of 132.163 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.712 hours/ns, 7.566 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    | 131.64     | 131.64     | 131.64     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086711   | 0.086711   | 0.086711   |   0.0 |  0.07
Output  | 0.0001563  | 0.0001563  | 0.0001563  |   0.0 |  0.00
Modify  | 0.38162    | 0.38162    | 0.38162    |   0.0 |  0.29
Other   |            | 0.05882    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3406.00 ave        3406 max        3406 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:      121136.0 ave      121136 max      121136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121136
Ave neighs/atom = 60.568000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.43028005388, Press = -7.47234974198121
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14772.803   -14772.803   -14857.804   -14857.804    328.96082    328.96082    36210.679    36210.679   -181.75267   -181.75267 
    9000   -14777.314   -14777.314   -14857.694   -14857.694    311.07897    311.07897    36216.749    36216.749   -749.86389   -749.86389 
Loop time of 130.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.662 ns/day, 36.247 hours/ns, 7.663 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    | 129.97     | 129.97     | 129.97     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085781   | 0.085781   | 0.085781   |   0.0 |  0.07
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.37919    | 0.37919    | 0.37919    |   0.0 |  0.29
Other   |            | 0.05897    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3396.00 ave        3396 max        3396 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:      121102.0 ave      121102 max      121102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121102
Ave neighs/atom = 60.551000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.304221865446, Press = -0.724224104111612
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.314   -14777.314   -14857.694   -14857.694    311.07897    311.07897    36216.749    36216.749   -749.86389   -749.86389 
   10000   -14781.168   -14781.168   -14859.122   -14859.122    301.68988    301.68988    36202.257    36202.257   -83.758661   -83.758661 
Loop time of 131.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.489 hours/ns, 7.613 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    | 130.83     | 130.83     | 130.83     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085085   | 0.085085   | 0.085085   |   0.0 |  0.06
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.38248    | 0.38248    | 0.38248    |   0.0 |  0.29
Other   |            | 0.05897    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3331.00 ave        3331 max        3331 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:      120916.0 ave      120916 max      120916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120916
Ave neighs/atom = 60.458000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.994628544219, Press = 3.61853864317187
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14781.168   -14781.168   -14859.122   -14859.122    301.68988    301.68988    36202.257    36202.257   -83.758661   -83.758661 
   11000   -14774.482   -14774.482   -14857.557   -14857.557    321.51133    321.51133    36212.645    36212.645    -286.4139    -286.4139 
Loop time of 130.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.209 hours/ns, 7.671 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    | 129.84     | 129.84     | 129.84     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084053   | 0.084053   | 0.084053   |   0.0 |  0.06
Output  | 0.00015715 | 0.00015715 | 0.00015715 |   0.0 |  0.00
Modify  | 0.37294    | 0.37294    | 0.37294    |   0.0 |  0.29
Other   |            | 0.05813    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 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:      120902.0 ave      120902 max      120902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120902
Ave neighs/atom = 60.451000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.52970224669, Press = 2.80068271308783
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.482   -14774.482   -14857.557   -14857.557    321.51133    321.51133    36212.645    36212.645    -286.4139    -286.4139 
   12000   -14778.936   -14778.936   -14856.228   -14856.228    299.12669    299.12669    36202.453    36202.453    115.18994    115.18994 
Loop time of 129.814 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.059 hours/ns, 7.703 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    | 129.3      | 129.3      | 129.3      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084744   | 0.084744   | 0.084744   |   0.0 |  0.07
Output  | 0.00019516 | 0.00019516 | 0.00019516 |   0.0 |  0.00
Modify  | 0.3738     | 0.3738     | 0.3738     |   0.0 |  0.29
Other   |            | 0.05882    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3360.00 ave        3360 max        3360 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:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.189175110444, Press = 1.50756964024899
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14778.936   -14778.936   -14856.228   -14856.228    299.12669    299.12669    36202.453    36202.453    115.18994    115.18994 
   13000   -14774.323   -14774.323   -14855.414   -14855.414    313.83042    313.83042    36219.959    36219.959   -475.88156   -475.88156 
Loop time of 128.851 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.792 hours/ns, 7.761 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    | 128.33     | 128.33     | 128.33     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085594   | 0.085594   | 0.085594   |   0.0 |  0.07
Output  | 0.00015654 | 0.00015654 | 0.00015654 |   0.0 |  0.00
Modify  | 0.37454    | 0.37454    | 0.37454    |   0.0 |  0.29
Other   |            | 0.05835    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3402.00 ave        3402 max        3402 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:      121014.0 ave      121014 max      121014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121014
Ave neighs/atom = 60.507000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.112222280811, Press = 0.278955973963859
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.323   -14774.323   -14855.414   -14855.414    313.83042    313.83042    36219.959    36219.959   -475.88156   -475.88156 
   14000   -14778.821   -14778.821   -14859.594   -14859.594    312.59956    312.59956    36225.425    36225.425   -1162.8302   -1162.8302 
Loop time of 127.25 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.347 hours/ns, 7.859 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    | 126.74     | 126.74     | 126.74     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084055   | 0.084055   | 0.084055   |   0.0 |  0.07
Output  | 0.00019659 | 0.00019659 | 0.00019659 |   0.0 |  0.00
Modify  | 0.36818    | 0.36818    | 0.36818    |   0.0 |  0.29
Other   |            | 0.05732    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3378.00 ave        3378 max        3378 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:      120984.0 ave      120984 max      120984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120984
Ave neighs/atom = 60.492000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.95368808945, Press = 0.958593588198138
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14778.821   -14778.821   -14859.594   -14859.594    312.59956    312.59956    36225.425    36225.425   -1162.8302   -1162.8302 
   15000   -14776.883   -14776.883   -14857.772   -14857.772    313.04931    313.04931    36229.767    36229.767   -1358.2479   -1358.2479 
Loop time of 128.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.720 hours/ns, 7.776 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    | 128.08     | 128.08     | 128.08     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084363   | 0.084363   | 0.084363   |   0.0 |  0.07
Output  | 0.00041021 | 0.00041021 | 0.00041021 |   0.0 |  0.00
Modify  | 0.37384    | 0.37384    | 0.37384    |   0.0 |  0.29
Other   |            | 0.05849    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3361.00 ave        3361 max        3361 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:      120956.0 ave      120956 max      120956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120956
Ave neighs/atom = 60.478000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.16308553655, Press = 4.19864681125005
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.883   -14776.883   -14857.772   -14857.772    313.04931    313.04931    36229.767    36229.767   -1358.2479   -1358.2479 
   16000   -14773.104   -14773.104   -14855.546   -14855.546    319.06028    319.06028    36196.399    36196.399    728.68875    728.68875 
Loop time of 127.487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.413 hours/ns, 7.844 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    | 126.98     | 126.98     | 126.98     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082664   | 0.082664   | 0.082664   |   0.0 |  0.06
Output  | 0.00015559 | 0.00015559 | 0.00015559 |   0.0 |  0.00
Modify  | 0.3633     | 0.3633     | 0.3633     |   0.0 |  0.28
Other   |            | 0.05728    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3329.00 ave        3329 max        3329 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:      120850.0 ave      120850 max      120850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120850
Ave neighs/atom = 60.425000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.288153218813, Press = 4.80291676781954
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14773.104   -14773.104   -14855.546   -14855.546    319.06028    319.06028    36196.399    36196.399    728.68875    728.68875 
   17000   -14777.384   -14777.384    -14856.98    -14856.98    308.04307    308.04307    36145.194    36145.194    3282.6452    3282.6452 
Loop time of 130.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.144 hours/ns, 7.685 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    | 129.6      | 129.6      | 129.6      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08394    | 0.08394    | 0.08394    |   0.0 |  0.06
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.37526    | 0.37526    | 0.37526    |   0.0 |  0.29
Other   |            | 0.05905    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 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:      121046.0 ave      121046 max      121046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121046
Ave neighs/atom = 60.523000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.453820146836, Press = 1.8835411691709
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.384   -14777.384    -14856.98    -14856.98    308.04307    308.04307    36145.194    36145.194    3282.6452    3282.6452 
   18000   -14775.828   -14775.828   -14859.883   -14859.883    325.30225    325.30225    36187.427    36187.427    823.14869    823.14869 
Loop time of 130.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.172 hours/ns, 7.679 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    | 129.7      | 129.7      | 129.7      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084981   | 0.084981   | 0.084981   |   0.0 |  0.07
Output  | 0.00027616 | 0.00027616 | 0.00027616 |   0.0 |  0.00
Modify  | 0.37672    | 0.37672    | 0.37672    |   0.0 |  0.29
Other   |            | 0.05859    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 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:      121220.0 ave      121220 max      121220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121220
Ave neighs/atom = 60.610000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.499357158651, Press = -2.69302235901623
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14775.828   -14775.828   -14859.883   -14859.883    325.30225    325.30225    36187.427    36187.427    823.14869    823.14869 
   19000   -14772.321   -14772.321   -14856.486   -14856.486    325.72767    325.72767    36225.084    36225.084   -851.53818   -851.53818 
Loop time of 129.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.076 hours/ns, 7.700 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    | 129.35     | 129.35     | 129.35     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084232   | 0.084232   | 0.084232   |   0.0 |  0.06
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.37919    | 0.37919    | 0.37919    |   0.0 |  0.29
Other   |            | 0.05886    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 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:      121040.0 ave      121040 max      121040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121040
Ave neighs/atom = 60.520000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.606480814689, Press = -0.648887483341994
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14772.321   -14772.321   -14856.486   -14856.486    325.72767    325.72767    36225.084    36225.084   -851.53818   -851.53818 
   20000   -14776.523   -14776.523   -14856.018   -14856.018    307.65576    307.65576    36216.545    36216.545   -513.89652   -513.89652 
Loop time of 130.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.662 ns/day, 36.236 hours/ns, 7.666 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    | 129.92     | 129.92     | 129.92     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085654   | 0.085654   | 0.085654   |   0.0 |  0.07
Output  | 0.00019133 | 0.00019133 | 0.00019133 |   0.0 |  0.00
Modify  | 0.37958    | 0.37958    | 0.37958    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3385.00 ave        3385 max        3385 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:      120996.0 ave      120996 max      120996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120996
Ave neighs/atom = 60.498000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.630239207998, Press = 0.894419293871479
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.523   -14776.523   -14856.018   -14856.018    307.65576    307.65576    36216.545    36216.545   -513.89652   -513.89652 
   21000   -14780.848   -14780.848   -14859.271   -14859.271    303.50606    303.50606    36199.844    36199.844    94.828251    94.828251 
Loop time of 128.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.765 hours/ns, 7.767 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    | 128.24     | 128.24     | 128.24     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084335   | 0.084335   | 0.084335   |   0.0 |  0.07
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.37044    | 0.37044    | 0.37044    |   0.0 |  0.29
Other   |            | 0.05876    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3381.00 ave        3381 max        3381 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:      121004.0 ave      121004 max      121004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121004
Ave neighs/atom = 60.502000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.535074614303, Press = 1.37566132827548
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14780.848   -14780.848   -14859.271   -14859.271    303.50606    303.50606    36199.844    36199.844    94.828251    94.828251 
   22000   -14775.549   -14775.549   -14858.805   -14858.805    322.20623    322.20623    36189.865    36189.865    817.97921    817.97921 
Loop time of 127.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.408 hours/ns, 7.845 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    | 126.96     | 126.96     | 126.96     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08297    | 0.08297    | 0.08297    |   0.0 |  0.07
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.36716    | 0.36716    | 0.36716    |   0.0 |  0.29
Other   |            | 0.05805    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3370.00 ave        3370 max        3370 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:      121068.0 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.395894805302, Press = 0.646741334357134
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14775.549   -14775.549   -14858.805   -14858.805    322.20623    322.20623    36189.865    36189.865    817.97921    817.97921 
   23000   -14779.207   -14779.207   -14859.981   -14859.981    312.60165    312.60165    36183.611    36183.611    980.51322    980.51322 
Loop time of 129.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 36.004 hours/ns, 7.715 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    | 129.1      | 129.1      | 129.1      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084721   | 0.084721   | 0.084721   |   0.0 |  0.07
Output  | 0.00019002 | 0.00019002 | 0.00019002 |   0.0 |  0.00
Modify  | 0.37228    | 0.37228    | 0.37228    |   0.0 |  0.29
Other   |            | 0.05813    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3379.00 ave        3379 max        3379 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:      121032.0 ave      121032 max      121032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121032
Ave neighs/atom = 60.516000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.224094687381, Press = -0.972831037749988
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14779.207   -14779.207   -14859.981   -14859.981    312.60165    312.60165    36183.611    36183.611    980.51322    980.51322 
   24000   -14777.654   -14777.654   -14857.857   -14857.857    310.39226    310.39226    36226.407    36226.407   -1120.2799   -1120.2799 
Loop time of 130.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.303 hours/ns, 7.652 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    | 130.17     | 130.17     | 130.17     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084807   | 0.084807   | 0.084807   |   0.0 |  0.06
Output  | 0.00019463 | 0.00019463 | 0.00019463 |   0.0 |  0.00
Modify  | 0.37706    | 0.37706    | 0.37706    |   0.0 |  0.29
Other   |            | 0.05848    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3319.00 ave        3319 max        3319 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:      120986.0 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120986
Ave neighs/atom = 60.493000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.258582843307, Press = -2.0498276176743
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -14777.654   -14777.654   -14857.857   -14857.857    310.39226    310.39226    36226.407    36226.407   -1120.2799   -1120.2799 
   25000   -14772.778   -14772.778   -14854.847   -14854.847    317.61587    317.61587    36260.524    36260.524   -2612.2877   -2612.2877 
Loop time of 131.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.641 hours/ns, 7.581 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    | 131.39     | 131.39     | 131.39     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083723   | 0.083723   | 0.083723   |   0.0 |  0.06
Output  | 0.00019847 | 0.00019847 | 0.00019847 |   0.0 |  0.00
Modify  | 0.3797     | 0.3797     | 0.3797     |   0.0 |  0.29
Other   |            | 0.05817    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3312.00 ave        3312 max        3312 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:      120930.0 ave      120930 max      120930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120930
Ave neighs/atom = 60.465000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.314446003579, Press = 0.228088392913679
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14772.778   -14772.778   -14854.847   -14854.847    317.61587    317.61587    36260.524    36260.524   -2612.2877   -2612.2877 
   26000   -14777.827   -14777.827   -14856.867   -14856.867    305.89406    305.89406    36219.376    36219.376   -765.76632   -765.76632 
Loop time of 131.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.546 hours/ns, 7.601 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.04     | 131.04     | 131.04     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08565    | 0.08565    | 0.08565    |   0.0 |  0.07
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.37867    | 0.37867    | 0.37867    |   0.0 |  0.29
Other   |            | 0.05863    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3348.00 ave        3348 max        3348 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:      120868.0 ave      120868 max      120868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120868
Ave neighs/atom = 60.434000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.414539135736, Press = 1.97794589324828
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.827   -14777.827   -14856.867   -14856.867    305.89406    305.89406    36219.376    36219.376   -765.76632   -765.76632 
   27000   -14770.846   -14770.846   -14853.348   -14853.348    319.29039    319.29039    36204.192    36204.192    496.22602    496.22602 
Loop time of 130.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.287 hours/ns, 7.655 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    | 130.11     | 130.11     | 130.11     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085202   | 0.085202   | 0.085202   |   0.0 |  0.07
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.37741    | 0.37741    | 0.37741    |   0.0 |  0.29
Other   |            | 0.05827    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      120928.0 ave      120928 max      120928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120928
Ave neighs/atom = 60.464000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50269987574, Press = 1.11908518583742
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14770.846   -14770.846   -14853.348   -14853.348    319.29039    319.29039    36204.192    36204.192    496.22602    496.22602 
   28000   -14775.918   -14775.918   -14856.502   -14856.502    311.86717    311.86717    36190.448    36190.448    929.62605    929.62605 
Loop time of 128.201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.611 hours/ns, 7.800 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    | 127.69     | 127.69     | 127.69     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084536   | 0.084536   | 0.084536   |   0.0 |  0.07
Output  | 0.00015702 | 0.00015702 | 0.00015702 |   0.0 |  0.00
Modify  | 0.3725     | 0.3725     | 0.3725     |   0.0 |  0.29
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3399.00 ave        3399 max        3399 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:      121096.0 ave      121096 max      121096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121096
Ave neighs/atom = 60.548000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.503234564817, Press = 0.440963664772277
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14775.918   -14775.918   -14856.502   -14856.502    311.86717    311.86717    36190.448    36190.448    929.62605    929.62605 
   29000   -14779.152   -14779.152    -14856.85    -14856.85    300.69911    300.69911     36199.54     36199.54    321.66503    321.66503 
Loop time of 129.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.939 hours/ns, 7.729 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    | 128.86     | 128.86     | 128.86     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085196   | 0.085196   | 0.085196   |   0.0 |  0.07
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.37931    | 0.37931    | 0.37931    |   0.0 |  0.29
Other   |            | 0.05913    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3362.00 ave        3362 max        3362 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:      120982.0 ave      120982 max      120982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120982
Ave neighs/atom = 60.491000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.507981588846, Press = -0.200763196443816
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14779.152   -14779.152    -14856.85    -14856.85    300.69911    300.69911     36199.54     36199.54    321.66503    321.66503 
   30000   -14774.061   -14774.061   -14855.008   -14855.008    313.27006    313.27006    36256.908    36256.908   -2446.9399   -2446.9399 
Loop time of 131.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.534 hours/ns, 7.603 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    | 130.99     | 130.99     | 130.99     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085272   | 0.085272   | 0.085272   |   0.0 |  0.06
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.38571    | 0.38571    | 0.38571    |   0.0 |  0.29
Other   |            | 0.0587     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 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:      121002.0 ave      121002 max      121002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121002
Ave neighs/atom = 60.501000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.438290075615, Press = -0.810271471229712
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.061   -14774.061   -14855.008   -14855.008    313.27006    313.27006    36256.908    36256.908   -2446.9399   -2446.9399 
   31000    -14779.97    -14779.97   -14859.734   -14859.734    308.69557    308.69557    36251.158    36251.158   -2646.3108   -2646.3108 
Loop time of 129.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.040 hours/ns, 7.707 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    | 129.23     | 129.23     | 129.23     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084977   | 0.084977   | 0.084977   |   0.0 |  0.07
Output  | 0.00021154 | 0.00021154 | 0.00021154 |   0.0 |  0.00
Modify  | 0.37655    | 0.37655    | 0.37655    |   0.0 |  0.29
Other   |            | 0.05812    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3329.00 ave        3329 max        3329 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:      120816.0 ave      120816 max      120816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120816
Ave neighs/atom = 60.408000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.365187906938, Press = 1.89427844618165
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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    -14779.97    -14779.97   -14859.734   -14859.734    308.69557    308.69557    36251.158    36251.158   -2646.3108   -2646.3108 
   32000   -14773.526   -14773.526   -14856.983   -14856.983    322.98572    322.98572    36209.805    36209.805   -60.198763   -60.198763 
Loop time of 130.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.177 hours/ns, 7.678 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    | 129.72     | 129.72     | 129.72     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084739   | 0.084739   | 0.084739   |   0.0 |  0.07
Output  | 0.0001539  | 0.0001539  | 0.0001539  |   0.0 |  0.00
Modify  | 0.37419    | 0.37419    | 0.37419    |   0.0 |  0.29
Other   |            | 0.05823    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3333.00 ave        3333 max        3333 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:      120826.0 ave      120826 max      120826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120826
Ave neighs/atom = 60.413000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.32782015392, Press = 1.94753054577539
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14773.526   -14773.526   -14856.983   -14856.983    322.98572    322.98572    36209.805    36209.805   -60.198763   -60.198763 
   33000   -14777.701   -14777.701   -14859.331   -14859.331    315.91467    315.91467     36181.63     36181.63    1085.1866    1085.1866 
Loop time of 131.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.405 hours/ns, 7.630 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    | 130.53     | 130.53     | 130.53     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085127   | 0.085127   | 0.085127   |   0.0 |  0.06
Output  | 0.00015419 | 0.00015419 | 0.00015419 |   0.0 |  0.00
Modify  | 0.38077    | 0.38077    | 0.38077    |   0.0 |  0.29
Other   |            | 0.05896    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3387.00 ave        3387 max        3387 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:      121000.0 ave      121000 max      121000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121000
Ave neighs/atom = 60.500000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.400308639026, Press = 1.04968105005123
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14777.701   -14777.701   -14859.331   -14859.331    315.91467    315.91467     36181.63     36181.63    1085.1866    1085.1866 
   34000   -14774.454   -14774.454   -14854.021   -14854.021    307.93399    307.93399    36191.874    36191.874    1060.9502    1060.9502 
Loop time of 129.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.904 hours/ns, 7.737 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    | 128.73     | 128.73     | 128.73     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086572   | 0.086572   | 0.086572   |   0.0 |  0.07
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.37511    | 0.37511    | 0.37511    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3420.00 ave        3420 max        3420 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:      121148.0 ave      121148 max      121148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121148
Ave neighs/atom = 60.574000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.449679982098, Press = 0.204579379468818
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.454   -14774.454   -14854.021   -14854.021    307.93399    307.93399    36191.874    36191.874    1060.9502    1060.9502 
   35000   -14779.233   -14779.233    -14858.96    -14858.96    308.55106    308.55106    36201.734    36201.734    57.268446    57.268446 
Loop time of 128.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.808 hours/ns, 7.757 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    | 128.39     | 128.39     | 128.39     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084464   | 0.084464   | 0.084464   |   0.0 |  0.07
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.37122    | 0.37122    | 0.37122    |   0.0 |  0.29
Other   |            | 0.05855    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      121154.0 ave      121154 max      121154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121154
Ave neighs/atom = 60.577000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.374133299678, Press = -0.828329001827494
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14779.233   -14779.233    -14858.96    -14858.96    308.55106    308.55106    36201.734    36201.734    57.268446    57.268446 
   36000   -14774.029   -14774.029   -14857.153   -14857.153     321.7002     321.7002    36263.478    36263.478   -2993.2185   -2993.2185 
Loop time of 129.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.103 hours/ns, 7.694 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    | 129.45     | 129.45     | 129.45     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085143   | 0.085143   | 0.085143   |   0.0 |  0.07
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.37982    | 0.37982    | 0.37982    |   0.0 |  0.29
Other   |            | 0.05877    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3386.00 ave        3386 max        3386 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:      121012.0 ave      121012 max      121012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121012
Ave neighs/atom = 60.506000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.350303891993, Press = -0.607504170823775
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -14774.029   -14774.029   -14857.153   -14857.153     321.7002     321.7002    36263.478    36263.478   -2993.2185   -2993.2185 
   37000   -14776.358   -14776.358   -14855.719   -14855.719    307.13496    307.13496    36251.432    36251.432   -2336.8276   -2336.8276 
Loop time of 128.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.697 hours/ns, 7.782 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    | 128        | 128        | 128        |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083616   | 0.083616   | 0.083616   |   0.0 |  0.07
Output  | 0.00026516 | 0.00026516 | 0.00026516 |   0.0 |  0.00
Modify  | 0.37129    | 0.37129    | 0.37129    |   0.0 |  0.29
Other   |            | 0.05773    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3303.00 ave        3303 max        3303 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:      120810.0 ave      120810 max      120810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120810
Ave neighs/atom = 60.405000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.343373321373, Press = 1.61286339574636
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.358   -14776.358   -14855.719   -14855.719    307.13496    307.13496    36251.432    36251.432   -2336.8276   -2336.8276 
   38000   -14775.641   -14775.641   -14855.173   -14855.173    307.79645    307.79645    36201.601    36201.601    406.61175    406.61175 
Loop time of 129.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.858 hours/ns, 7.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.57     | 128.57     | 128.57     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085401   | 0.085401   | 0.085401   |   0.0 |  0.07
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.37601    | 0.37601    | 0.37601    |   0.0 |  0.29
Other   |            | 0.05814    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3334.00 ave        3334 max        3334 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:      120966.0 ave      120966 max      120966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120966
Ave neighs/atom = 60.483000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.425984269741, Press = 1.61765515120732
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14775.641   -14775.641   -14855.173   -14855.173    307.79645    307.79645    36201.601    36201.601    406.61175    406.61175 
   39000   -14774.099   -14774.099   -14857.064   -14857.064    321.08639    321.08639    36191.708    36191.708    757.06124    757.06124 
Loop time of 128.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.699 hours/ns, 7.781 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    | 128        | 128        | 128        |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085261   | 0.085261   | 0.085261   |   0.0 |  0.07
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.3719     | 0.3719     | 0.3719     |   0.0 |  0.29
Other   |            | 0.05836    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3411.00 ave        3411 max        3411 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:      120992.0 ave      120992 max      120992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120992
Ave neighs/atom = 60.496000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.44503415603, Press = 0.798411634100672
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.099   -14774.099   -14857.064   -14857.064    321.08639    321.08639    36191.708    36191.708    757.06124    757.06124 
   40000   -14778.224   -14778.224    -14860.46    -14860.46    318.26322    318.26322     36175.98     36175.98    1332.7878    1332.7878 
Loop time of 129.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.098 hours/ns, 7.695 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    | 129.43     | 129.43     | 129.43     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0857     | 0.0857     | 0.0857     |   0.0 |  0.07
Output  | 0.00015127 | 0.00015127 | 0.00015127 |   0.0 |  0.00
Modify  | 0.37908    | 0.37908    | 0.37908    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3387.00 ave        3387 max        3387 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:      121118.0 ave      121118 max      121118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121118
Ave neighs/atom = 60.559000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.456594233478, Press = 0.151735452409081
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14778.224   -14778.224    -14860.46    -14860.46    318.26322    318.26322     36175.98     36175.98    1332.7878    1332.7878 
   41000   -14776.487   -14776.487   -14856.582   -14856.582    309.97538    309.97538    36207.814    36207.814   -79.393941   -79.393941 
Loop time of 129.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.840 hours/ns, 7.750 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    | 128.51     | 128.51     | 128.51     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083934   | 0.083934   | 0.083934   |   0.0 |  0.07
Output  | 0.00041152 | 0.00041152 | 0.00041152 |   0.0 |  0.00
Modify  | 0.36873    | 0.36873    | 0.36873    |   0.0 |  0.29
Other   |            | 0.058      |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3401.00 ave        3401 max        3401 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:      121080.0 ave      121080 max      121080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121080
Ave neighs/atom = 60.540000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.437758057029, Press = -0.737874725313711
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.487   -14776.487   -14856.582   -14856.582    309.97538    309.97538    36207.814    36207.814   -79.393941   -79.393941 
   42000   -14777.041   -14777.041   -14854.842   -14854.842    301.09763    301.09763    36253.938    36253.938    -2400.685    -2400.685 
Loop time of 129.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.847 hours/ns, 7.749 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    | 128.53     | 128.53     | 128.53     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084299   | 0.084299   | 0.084299   |   0.0 |  0.07
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.37298    | 0.37298    | 0.37298    |   0.0 |  0.29
Other   |            | 0.05827    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 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:      121048.0 ave      121048 max      121048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121048
Ave neighs/atom = 60.524000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.350200676777, Press = -0.481327625778356
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -14777.041   -14777.041   -14854.842   -14854.842    301.09763    301.09763    36253.938    36253.938    -2400.685    -2400.685 
   43000   -14778.183   -14778.183   -14857.637   -14857.637     307.4935     307.4935    36292.381    36292.381   -4669.3543   -4669.3543 
Loop time of 130.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.201 hours/ns, 7.673 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    | 129.81     | 129.81     | 129.81     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083764   | 0.083764   | 0.083764   |   0.0 |  0.06
Output  | 0.00015488 | 0.00015488 | 0.00015488 |   0.0 |  0.00
Modify  | 0.37528    | 0.37528    | 0.37528    |   0.0 |  0.29
Other   |            | 0.05774    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3290.00 ave        3290 max        3290 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:      120862.0 ave      120862 max      120862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120862
Ave neighs/atom = 60.431000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.326836444653, Press = 2.38659496946227
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14778.183   -14778.183   -14857.637   -14857.637     307.4935     307.4935    36292.381    36292.381   -4669.3543   -4669.3543 
   44000   -14776.066   -14776.066   -14857.677   -14857.677    315.84234    315.84234    36193.039    36193.039    676.60779    676.60779 
Loop time of 131.101 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.417 hours/ns, 7.628 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    | 130.57     | 130.57     | 130.57     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086328   | 0.086328   | 0.086328   |   0.0 |  0.07
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.38764    | 0.38764    | 0.38764    |   0.0 |  0.30
Other   |            | 0.0596     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3325.00 ave        3325 max        3325 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:      120652.0 ave      120652 max      120652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120652
Ave neighs/atom = 60.326000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.286992396625, Press = 1.84564164666061
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.066   -14776.066   -14857.677   -14857.677    315.84234    315.84234    36193.039    36193.039    676.60779    676.60779 
   45000    -14778.19    -14778.19   -14858.901   -14858.901    312.35857    312.35857    36183.742    36183.742    1053.9512    1053.9512 
Loop time of 127.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.465 hours/ns, 7.832 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    | 127.16     | 127.16     | 127.16     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084317   | 0.084317   | 0.084317   |   0.0 |  0.07
Output  | 0.00018819 | 0.00018819 | 0.00018819 |   0.0 |  0.00
Modify  | 0.3712     | 0.3712     | 0.3712     |   0.0 |  0.29
Other   |            | 0.05856    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3395.00 ave        3395 max        3395 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:      121042.0 ave      121042 max      121042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121042
Ave neighs/atom = 60.521000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.310196838184, Press = 0.941130661629813
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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    -14778.19    -14778.19   -14858.901   -14858.901    312.35857    312.35857    36183.742    36183.742    1053.9512    1053.9512 
   46000   -14776.527   -14776.527   -14857.219   -14857.219    312.28565    312.28565    36179.749    36179.749    1426.5756    1426.5756 
Loop time of 129.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.962 hours/ns, 7.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    | 128.94     | 128.94     | 128.94     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08502    | 0.08502    | 0.08502    |   0.0 |  0.07
Output  | 0.00019445 | 0.00019445 | 0.00019445 |   0.0 |  0.00
Modify  | 0.37601    | 0.37601    | 0.37601    |   0.0 |  0.29
Other   |            | 0.05859    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3386.00 ave        3386 max        3386 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:      121016.0 ave      121016 max      121016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121016
Ave neighs/atom = 60.508000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.303927602791, Press = 0.250850732002871
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14776.527   -14776.527   -14857.219   -14857.219    312.28565    312.28565    36179.749    36179.749    1426.5756    1426.5756 
   47000    -14775.51    -14775.51   -14857.361   -14857.361    316.77207    316.77207    36207.281    36207.281    21.227339    21.227339 
Loop time of 129.637 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.010 hours/ns, 7.714 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    | 129.12     | 129.12     | 129.12     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085798   | 0.085798   | 0.085798   |   0.0 |  0.07
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.37459    | 0.37459    | 0.37459    |   0.0 |  0.29
Other   |            | 0.05855    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3395.00 ave        3395 max        3395 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:      121068.0 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.343681724458, Press = -0.355474325539826
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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    -14775.51    -14775.51   -14857.361   -14857.361    316.77207    316.77207    36207.281    36207.281    21.227339    21.227339 
   48000   -14776.579   -14776.579   -14857.504   -14857.504    313.19075    313.19075     36250.42     36250.42   -2344.6127   -2344.6127 
Loop time of 125.283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.801 hours/ns, 7.982 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    | 124.78     | 124.78     | 124.78     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08242    | 0.08242    | 0.08242    |   0.0 |  0.07
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.36042    | 0.36042    | 0.36042    |   0.0 |  0.29
Other   |            | 0.0572     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 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:      121022.0 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.351116019711, Press = -0.282327311847074
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -14776.579   -14776.579   -14857.504   -14857.504    313.19075    313.19075     36250.42     36250.42   -2344.6127   -2344.6127 
   49000   -14774.709   -14774.709   -14855.805   -14855.805    313.85256    313.85256    36267.396    36267.396   -3133.3549   -3133.3549 
Loop time of 129.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.864 hours/ns, 7.745 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    | 128.59     | 128.59     | 128.59     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083972   | 0.083972   | 0.083972   |   0.0 |  0.07
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.37473    | 0.37473    | 0.37473    |   0.0 |  0.29
Other   |            | 0.0589     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3311.00 ave        3311 max        3311 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:      120862.0 ave      120862 max      120862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120862
Ave neighs/atom = 60.431000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.350716887626, Press = 1.09049716610809
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.709   -14774.709   -14855.805   -14855.805    313.85256    313.85256    36267.396    36267.396   -3133.3549   -3133.3549 
   50000   -14780.242   -14780.242   -14860.003   -14860.003    308.68508    308.68508    36207.793    36207.793   -372.65271   -372.65271 
Loop time of 129.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.060 hours/ns, 7.703 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    | 129.3      | 129.3      | 129.3      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084479   | 0.084479   | 0.084479   |   0.0 |  0.07
Output  | 0.00015599 | 0.00015599 | 0.00015599 |   0.0 |  0.00
Modify  | 0.37415    | 0.37415    | 0.37415    |   0.0 |  0.29
Other   |            | 0.05826    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3350.00 ave        3350 max        3350 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:      120802.0 ave      120802 max      120802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120802
Ave neighs/atom = 60.401000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.302029881435, Press = 1.25324526912659
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14780.242   -14780.242   -14860.003   -14860.003    308.68508    308.68508    36207.793    36207.793   -372.65271   -372.65271 
   51000   -14774.648   -14774.648   -14856.171   -14856.171    315.49891    315.49891    36187.951    36187.951     1138.118     1138.118 
Loop time of 126.832 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.231 hours/ns, 7.884 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    | 126.33     | 126.33     | 126.33     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082758   | 0.082758   | 0.082758   |   0.0 |  0.07
Output  | 0.00020837 | 0.00020837 | 0.00020837 |   0.0 |  0.00
Modify  | 0.36344    | 0.36344    | 0.36344    |   0.0 |  0.29
Other   |            | 0.05711    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3331.00 ave        3331 max        3331 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:      121010.0 ave      121010 max      121010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121010
Ave neighs/atom = 60.505000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.273575814021, Press = 0.649746292739461
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.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14774.648   -14774.648   -14856.171   -14856.171    315.49891    315.49891    36187.951    36187.951     1138.118     1138.118 
   52000   -14777.534   -14777.534   -14856.994   -14856.994    307.51868    307.51868    36199.094    36199.094    346.06447    346.06447 
Loop time of 126.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.205 hours/ns, 7.890 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    | 126.23     | 126.23     | 126.23     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08354    | 0.08354    | 0.08354    |   0.0 |  0.07
Output  | 0.00015509 | 0.00015509 | 0.00015509 |   0.0 |  0.00
Modify  | 0.36529    | 0.36529    | 0.36529    |   0.0 |  0.29
Other   |            | 0.05796    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      121076.0 ave      121076 max      121076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0