# 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 2.863657310605049*${_u_distance}
variable latticeconst_converted equal 2.863657310605049*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365731060505
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
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 (28.636573 28.636573 28.636573)
  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 (28.636573 28.636573 28.636573)
  create_atoms CPU = 0.003 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_ChoiKimSeol_2017_CoFe__MO_179158257180_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 23483.5168277961    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5168277961/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5168277961/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5168277961/(1*1*${_u_distance})
variable      V0_metal equal 23483.5168277961/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23483.5168277961*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5168277961 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_179158257180_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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8499.0849   -8499.0849        -8580        -8580       313.15       313.15    23483.517    23483.517    3680.3383    3680.3383 
    1000    -8414.062    -8414.062   -8492.0255   -8492.0255    301.72682    301.72682    23708.302    23708.302    2542.4029    2542.4029 
Loop time of 133.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.030 hours/ns, 7.501 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    | 132.8      | 132.8      | 132.8      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096492   | 0.096492   | 0.096492   |   0.0 |  0.07
Output  | 0.00023517 | 0.00023517 | 0.00023517 |   0.0 |  0.00
Modify  | 0.3465     | 0.3465     | 0.3465     |   0.0 |  0.26
Other   |            | 0.06047    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.636 ns/day, 37.708 hours/ns, 7.366 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    | 135.26     | 135.26     | 135.26     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094554   | 0.094554   | 0.094554   |   0.0 |  0.07
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.33249    | 0.33249    | 0.33249    |   0.0 |  0.24
Other   |            | 0.05899    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128076.0 ave      128076 max      128076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.635 ns/day, 37.798 hours/ns, 7.349 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    | 135.59     | 135.59     | 135.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095048   | 0.095048   | 0.095048   |   0.0 |  0.07
Output  | 0.00022715 | 0.00022715 | 0.00022715 |   0.0 |  0.00
Modify  | 0.33343    | 0.33343    | 0.33343    |   0.0 |  0.25
Other   |            | 0.05923    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128102.0 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.636 ns/day, 37.748 hours/ns, 7.359 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    | 135.41     | 135.41     | 135.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094803   | 0.094803   | 0.094803   |   0.0 |  0.07
Output  | 0.00018816 | 0.00018816 | 0.00018816 |   0.0 |  0.00
Modify  | 0.33289    | 0.33289    | 0.33289    |   0.0 |  0.24
Other   |            | 0.0593     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128048.0 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.636 ns/day, 37.754 hours/ns, 7.358 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    | 135.43     | 135.43     | 135.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095229   | 0.095229   | 0.095229   |   0.0 |  0.07
Output  | 0.00015256 | 0.00015256 | 0.00015256 |   0.0 |  0.00
Modify  | 0.33364    | 0.33364    | 0.33364    |   0.0 |  0.25
Other   |            | 0.05881    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128024.0 ave      128024 max      128024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128024
Ave neighs/atom = 64.012000
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.069165072102, Press = 1174.45647265193
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8415.9571   -8415.9571   -8498.1066   -8498.1066    317.92724    317.92724    23721.375    23721.375    911.04446    911.04446 
    6000   -8413.7763   -8413.7763    -8498.326    -8498.326    327.21613    327.21613    23685.076    23685.076    3615.8594    3615.8594 
Loop time of 135.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.624 hours/ns, 7.383 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    | 134.94     | 134.94     | 134.94     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094682   | 0.094682   | 0.094682   |   0.0 |  0.07
Output  | 0.00015282 | 0.00015282 | 0.00015282 |   0.0 |  0.00
Modify  | 0.3485     | 0.3485     | 0.3485     |   0.0 |  0.26
Other   |            | 0.05772    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128046.0 ave      128046 max      128046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128046
Ave neighs/atom = 64.023000
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 = 311.959595069822, Press = 91.8072388357307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8413.7763   -8413.7763    -8498.326    -8498.326    327.21613    327.21613    23685.076    23685.076    3615.8594    3615.8594 
    7000   -8418.4177   -8418.4177     -8499.41     -8499.41    313.44883    313.44883    23710.651    23710.651    1369.6543    1369.6543 
Loop time of 135.483 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.634 hours/ns, 7.381 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    | 134.98     | 134.98     | 134.98     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095094   | 0.095094   | 0.095094   |   0.0 |  0.07
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.34906    | 0.34906    | 0.34906    |   0.0 |  0.26
Other   |            | 0.05838    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128086.0 ave      128086 max      128086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128086
Ave neighs/atom = 64.043000
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 = 311.671257122998, Press = 15.1596222859904
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8418.4177   -8418.4177     -8499.41     -8499.41    313.44883    313.44883    23710.651    23710.651    1369.6543    1369.6543 
    8000   -8414.3589   -8414.3589   -8495.3885   -8495.3885    313.59303    313.59303    23736.073    23736.073     185.3391     185.3391 
Loop time of 135.238 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.566 hours/ns, 7.394 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.74     | 134.74     | 134.74     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094947   | 0.094947   | 0.094947   |   0.0 |  0.07
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.34838    | 0.34838    | 0.34838    |   0.0 |  0.26
Other   |            | 0.05857    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128034.0 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017000
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 = 311.319776023706, Press = 9.41198435897028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8414.3589   -8414.3589   -8495.3885   -8495.3885    313.59303    313.59303    23736.073    23736.073     185.3391     185.3391 
    9000    -8416.352    -8416.352     -8494.43     -8494.43    302.16987    302.16987     23743.61     23743.61   -280.05821   -280.05821 
Loop time of 135.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.653 hours/ns, 7.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.05     | 135.05     | 135.05     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094449   | 0.094449   | 0.094449   |   0.0 |  0.07
Output  | 0.00015477 | 0.00015477 | 0.00015477 |   0.0 |  0.00
Modify  | 0.34887    | 0.34887    | 0.34887    |   0.0 |  0.26
Other   |            | 0.05846    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128036.0 ave      128036 max      128036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128036
Ave neighs/atom = 64.018000
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 = 311.618545780351, Press = 8.26579509205349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8416.352    -8416.352     -8494.43     -8494.43    302.16987    302.16987     23743.61     23743.61   -280.05821   -280.05821 
   10000   -8412.7379   -8412.7379   -8494.8522   -8494.8522     317.7907     317.7907    23757.258    23757.258   -1184.3877   -1184.3877 
Loop time of 135.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.681 hours/ns, 7.372 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.15     | 135.15     | 135.15     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094833   | 0.094833   | 0.094833   |   0.0 |  0.07
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.34919    | 0.34919    | 0.34919    |   0.0 |  0.26
Other   |            | 0.0585     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128058.0 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029000
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 = 311.362882520185, Press = 7.88017509054711
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8412.7379   -8412.7379   -8494.8522   -8494.8522     317.7907     317.7907    23757.258    23757.258   -1184.3877   -1184.3877 
   11000   -8414.8368   -8414.8368   -8496.1028   -8496.1028    314.50802    314.50802    23766.434    23766.434   -1970.8886   -1970.8886 
Loop time of 135.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.655 hours/ns, 7.377 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.05     | 135.05     | 135.05     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09517    | 0.09517    | 0.09517    |   0.0 |  0.07
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.34892    | 0.34892    | 0.34892    |   0.0 |  0.26
Other   |            | 0.05835    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128034.0 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017000
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 = 311.742956277328, Press = 7.54623910517724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8414.8368   -8414.8368   -8496.1028   -8496.1028    314.50802    314.50802    23766.434    23766.434   -1970.8886   -1970.8886 
   12000   -8414.4914   -8414.4914   -8496.1106   -8496.1106    315.87491    315.87491    23766.456    23766.456   -1917.1046   -1917.1046 
Loop time of 135.692 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.692 hours/ns, 7.370 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.19     | 135.19     | 135.19     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094682   | 0.094682   | 0.094682   |   0.0 |  0.07
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.34814    | 0.34814    | 0.34814    |   0.0 |  0.26
Other   |            | 0.05877    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128014.0 ave      128014 max      128014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128014
Ave neighs/atom = 64.007000
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.412717502566, Press = 12.4544668882844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8414.4914   -8414.4914   -8496.1106   -8496.1106    315.87491    315.87491    23766.456    23766.456   -1917.1046   -1917.1046 
   13000   -8412.4545   -8412.4545   -8494.2157   -8494.2157    316.42424    316.42424    23752.086    23752.086   -695.94211   -695.94211 
Loop time of 135.499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.639 hours/ns, 7.380 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    | 135        | 135        | 135        |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094292   | 0.094292   | 0.094292   |   0.0 |  0.07
Output  | 0.00015378 | 0.00015378 | 0.00015378 |   0.0 |  0.00
Modify  | 0.34905    | 0.34905    | 0.34905    |   0.0 |  0.26
Other   |            | 0.05858    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128020.0 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.010000
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.523930696363, Press = 14.3090457162474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8412.4545   -8412.4545   -8494.2157   -8494.2157    316.42424    316.42424    23752.086    23752.086   -695.94211   -695.94211 
   14000   -8416.1103   -8416.1103   -8497.9154   -8497.9154    316.59443    316.59443    23717.477    23717.477    1057.8702    1057.8702 
Loop time of 135.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.622 hours/ns, 7.383 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    | 134.94     | 134.94     | 134.94     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09479    | 0.09479    | 0.09479    |   0.0 |  0.07
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.34876    | 0.34876    | 0.34876    |   0.0 |  0.26
Other   |            | 0.05835    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128022.0 ave      128022 max      128022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128022
Ave neighs/atom = 64.011000
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.734715886853, Press = 12.3113701947516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8416.1103   -8416.1103   -8497.9154   -8497.9154    316.59443    316.59443    23717.477    23717.477    1057.8702    1057.8702 
   15000   -8412.3635   -8412.3635   -8494.0267   -8494.0267      316.045      316.045    23724.946    23724.946     1279.684     1279.684 
Loop time of 135.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.681 hours/ns, 7.372 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    | 135.15     | 135.15     | 135.15     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09463    | 0.09463    | 0.09463    |   0.0 |  0.07
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.3487     | 0.3487     | 0.3487     |   0.0 |  0.26
Other   |            | 0.05832    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128030.0 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015000
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.683347546046, Press = 6.31465811150679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8412.3635   -8412.3635   -8494.0267   -8494.0267      316.045      316.045    23724.946    23724.946     1279.684     1279.684 
   16000   -8417.5689   -8417.5689   -8496.2893   -8496.2893    304.65612    304.65612    23726.209    23726.209    800.78148    800.78148 
Loop time of 135.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.682 hours/ns, 7.372 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    | 135.15     | 135.15     | 135.15     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095108   | 0.095108   | 0.095108   |   0.0 |  0.07
Output  | 0.00015655 | 0.00015655 | 0.00015655 |   0.0 |  0.00
Modify  | 0.34868    | 0.34868    | 0.34868    |   0.0 |  0.26
Other   |            | 0.05898    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128048.0 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024000
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.795033353463, Press = 3.55792613844976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8417.5689   -8417.5689   -8496.2893   -8496.2893    304.65612    304.65612    23726.209    23726.209    800.78148    800.78148 
   17000   -8409.6336   -8409.6336   -8494.9123   -8494.9123    330.03765    330.03765    23741.734    23741.734    129.59762    129.59762 
Loop time of 135.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.611 hours/ns, 7.386 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    | 134.9      | 134.9      | 134.9      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095446   | 0.095446   | 0.095446   |   0.0 |  0.07
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.34864    | 0.34864    | 0.34864    |   0.0 |  0.26
Other   |            | 0.05837    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128052.0 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026000
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.919771600791, Press = 2.70708742243572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8409.6336   -8409.6336   -8494.9123   -8494.9123    330.03765    330.03765    23741.734    23741.734    129.59762    129.59762 
   18000   -8415.4947   -8415.4947   -8496.8207   -8496.8207    314.74037    314.74037    23734.591    23734.591    40.317552    40.317552 
Loop time of 135.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.677 hours/ns, 7.373 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    | 135.14     | 135.14     | 135.14     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094532   | 0.094532   | 0.094532   |   0.0 |  0.07
Output  | 0.00015454 | 0.00015454 | 0.00015454 |   0.0 |  0.00
Modify  | 0.34803    | 0.34803    | 0.34803    |   0.0 |  0.26
Other   |            | 0.05858    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128032.0 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016000
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.075329803485, Press = 1.16072379981415
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8415.4947   -8415.4947   -8496.8207   -8496.8207    314.74037    314.74037    23734.591    23734.591    40.317552    40.317552 
   19000   -8413.6359   -8413.6359   -8493.6294   -8493.6294    309.58298    309.58298    23758.518    23758.518   -1185.3901   -1185.3901 
Loop time of 135.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.702 hours/ns, 7.368 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    | 135.23     | 135.23     | 135.23     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095001   | 0.095001   | 0.095001   |   0.0 |  0.07
Output  | 0.00015376 | 0.00015376 | 0.00015376 |   0.0 |  0.00
Modify  | 0.34874    | 0.34874    | 0.34874    |   0.0 |  0.26
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:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128058.0 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029000
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.260369181032, Press = -3.35552435137282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8413.6359   -8413.6359   -8493.6294   -8493.6294    309.58298    309.58298    23758.518    23758.518   -1185.3901   -1185.3901 
   20000   -8413.4579   -8413.4579    -8495.293    -8495.293    316.71036    316.71036    23779.025    23779.025   -2878.2664   -2878.2664 
Loop time of 135.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.715 hours/ns, 7.365 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    | 135.27     | 135.27     | 135.27     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094962   | 0.094962   | 0.094962   |   0.0 |  0.07
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.34946    | 0.34946    | 0.34946    |   0.0 |  0.26
Other   |            | 0.05861    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128042.0 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021000
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.213754960111, Press = -0.422929055173351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8413.4579   -8413.4579    -8495.293    -8495.293    316.71036    316.71036    23779.025    23779.025   -2878.2664   -2878.2664 
   21000    -8414.394    -8414.394   -8496.0341   -8496.0341    315.95564    315.95564    23772.484    23772.484   -2513.4077   -2513.4077 
Loop time of 135.746 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.707 hours/ns, 7.367 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    | 135.24     | 135.24     | 135.24     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095044   | 0.095044   | 0.095044   |   0.0 |  0.07
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.34753    | 0.34753    | 0.34753    |   0.0 |  0.26
Other   |            | 0.05842    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128062.0 ave      128062 max      128062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128062
Ave neighs/atom = 64.031000
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.109243397716, Press = 3.04625609191943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -8414.394    -8414.394   -8496.0341   -8496.0341    315.95564    315.95564    23772.484    23772.484   -2513.4077   -2513.4077 
   22000   -8411.1629   -8411.1629   -8494.6178   -8494.6178    322.97912    322.97912    23758.496    23758.496   -1140.2038   -1140.2038 
Loop time of 135.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.610 hours/ns, 7.386 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    | 134.9      | 134.9      | 134.9      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094766   | 0.094766   | 0.094766   |   0.0 |  0.07
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.34881    | 0.34881    | 0.34881    |   0.0 |  0.26
Other   |            | 0.05793    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128038.0 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019000
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.063780839924, Press = 4.21733247121286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8411.1629   -8411.1629   -8494.6178   -8494.6178    322.97912    322.97912    23758.496    23758.496   -1140.2038   -1140.2038 
   23000   -8416.5374   -8416.5374   -8495.7087   -8495.7087    306.40119    306.40119    23734.341    23734.341     232.6042     232.6042 
Loop time of 135.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.712 hours/ns, 7.366 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    | 135.26     | 135.26     | 135.26     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095379   | 0.095379   | 0.095379   |   0.0 |  0.07
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.34861    | 0.34861    | 0.34861    |   0.0 |  0.26
Other   |            | 0.05831    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      128030.0 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015000
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.234275238711, Press = 3.60774590182051
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8416.5374   -8416.5374   -8495.7087   -8495.7087    306.40119    306.40119    23734.341    23734.341     232.6042     232.6042 
   24000   -8413.5464   -8413.5464   -8494.5086   -8494.5086    313.33228    313.33228    23732.554    23732.554    780.11547    780.11547 
Loop time of 135.59 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.664 hours/ns, 7.375 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    | 135.09     | 135.09     | 135.09     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094068   | 0.094068   | 0.094068   |   0.0 |  0.07
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.34876    | 0.34876    | 0.34876    |   0.0 |  0.26
Other   |            | 0.0583     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128074.0 ave      128074 max      128074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128074
Ave neighs/atom = 64.037000
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.263422294115, Press = 3.02325641972342
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8413.5464   -8413.5464   -8494.5086   -8494.5086    313.33228    313.33228    23732.554    23732.554    780.11547    780.11547 
   25000   -8413.4001   -8413.4001   -8495.6883   -8495.6883    318.46374    318.46374    23722.718    23722.718     1207.399     1207.399 
Loop time of 135.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.637 hours/ns, 7.380 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    | 134.99     | 134.99     | 134.99     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094397   | 0.094397   | 0.094397   |   0.0 |  0.07
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.34865    | 0.34865    | 0.34865    |   0.0 |  0.26
Other   |            | 0.05853    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128042.0 ave      128042 max      128042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128042
Ave neighs/atom = 64.021000
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.216942468931, Press = 2.88286891550431
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8413.4001   -8413.4001   -8495.6883   -8495.6883    318.46374    318.46374    23722.718    23722.718     1207.399     1207.399 
   26000   -8416.4206   -8416.4206   -8494.3659   -8494.3659    301.65629    301.65629    23698.022    23698.022     3036.249     3036.249 
Loop time of 135.662 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.684 hours/ns, 7.371 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    | 135.16     | 135.16     | 135.16     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094726   | 0.094726   | 0.094726   |   0.0 |  0.07
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.34836    | 0.34836    | 0.34836    |   0.0 |  0.26
Other   |            | 0.05852    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128066.0 ave      128066 max      128066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128066
Ave neighs/atom = 64.033000
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.295744006415, Press = 0.722640423711884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8416.4206   -8416.4206   -8494.3659   -8494.3659    301.65629    301.65629    23698.022    23698.022     3036.249     3036.249 
   27000   -8411.2638   -8411.2638   -8493.7202   -8493.7202    319.11476    319.11476    23722.148    23722.148    1674.7917    1674.7917 
Loop time of 135.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.699 hours/ns, 7.368 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    | 135.21     | 135.21     | 135.21     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094748   | 0.094748   | 0.094748   |   0.0 |  0.07
Output  | 0.00015372 | 0.00015372 | 0.00015372 |   0.0 |  0.00
Modify  | 0.35029    | 0.35029    | 0.35029    |   0.0 |  0.26
Other   |            | 0.05864    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128048.0 ave      128048 max      128048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128048
Ave neighs/atom = 64.024000
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.267837019969, Press = -1.82261628429298
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8411.2638   -8411.2638   -8493.7202   -8493.7202    319.11476    319.11476    23722.148    23722.148    1674.7917    1674.7917 
   28000   -8415.0228   -8415.0228   -8495.1756   -8495.1756    310.19955    310.19955    23748.592    23748.592   -600.05859   -600.05859 
Loop time of 135.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.626 hours/ns, 7.383 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    | 134.95     | 134.95     | 134.95     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095673   | 0.095673   | 0.095673   |   0.0 |  0.07
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.34926    | 0.34926    | 0.34926    |   0.0 |  0.26
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:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128034.0 ave      128034 max      128034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128034
Ave neighs/atom = 64.017000
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.378084183372, Press = -0.795205103646353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8415.0228   -8415.0228   -8495.1756   -8495.1756    310.19955    310.19955    23748.592    23748.592   -600.05859   -600.05859 
   29000   -8415.6816   -8415.6816   -8495.4814   -8495.4814    308.83354    308.83354    23759.467    23759.467   -1497.2924   -1497.2924 
Loop time of 135.518 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.644 hours/ns, 7.379 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    | 135.01     | 135.01     | 135.01     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095464   | 0.095464   | 0.095464   |   0.0 |  0.07
Output  | 0.00015334 | 0.00015334 | 0.00015334 |   0.0 |  0.00
Modify  | 0.35055    | 0.35055    | 0.35055    |   0.0 |  0.26
Other   |            | 0.05833    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128026.0 ave      128026 max      128026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128026
Ave neighs/atom = 64.013000
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.326769951629, Press = 1.64827335475002
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8415.6816   -8415.6816   -8495.4814   -8495.4814    308.83354    308.83354    23759.467    23759.467   -1497.2924   -1497.2924 
   30000   -8415.5383   -8415.5383   -8496.4015   -8496.4015    312.94892    312.94892    23749.047    23749.047   -812.16295   -812.16295 
Loop time of 135.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.689 hours/ns, 7.370 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    | 135.18     | 135.18     | 135.18     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095587   | 0.095587   | 0.095587   |   0.0 |  0.07
Output  | 0.00042999 | 0.00042999 | 0.00042999 |   0.0 |  0.00
Modify  | 0.34944    | 0.34944    | 0.34944    |   0.0 |  0.26
Other   |            | 0.05865    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128038.0 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019000
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.263430362704, Press = 2.93341426894394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8415.5383   -8415.5383   -8496.4015   -8496.4015    312.94892    312.94892    23749.047    23749.047   -812.16295   -812.16295 
   31000   -8415.9645   -8415.9645   -8496.1912   -8496.1912    310.48544    310.48544    23735.601    23735.601    148.32011    148.32011 
Loop time of 136.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.028 hours/ns, 7.304 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    | 136.39     | 136.39     | 136.39     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095553   | 0.095553   | 0.095553   |   0.0 |  0.07
Output  | 0.00019332 | 0.00019332 | 0.00019332 |   0.0 |  0.00
Modify  | 0.35289    | 0.35289    | 0.35289    |   0.0 |  0.26
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:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128050.0 ave      128050 max      128050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128050
Ave neighs/atom = 64.025000
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.148138523092, Press = 3.62801152729899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8415.9645   -8415.9645   -8496.1912   -8496.1912    310.48544    310.48544    23735.601    23735.601    148.32011    148.32011 
   32000   -8412.7428   -8412.7428   -8494.3745   -8494.3745    315.92291    315.92291    23713.908    23713.908    2129.5383    2129.5383 
Loop time of 136.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.635 ns/day, 37.802 hours/ns, 7.348 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    | 135.58     | 135.58     | 135.58     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095652   | 0.095652   | 0.095652   |   0.0 |  0.07
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.35057    | 0.35057    | 0.35057    |   0.0 |  0.26
Other   |            | 0.05824    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128058.0 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029000
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.026586309362, Press = 3.36217097588185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8412.7428   -8412.7428   -8494.3745   -8494.3745    315.92291    315.92291    23713.908    23713.908    2129.5383    2129.5383 
   33000   -8417.5321   -8417.5321   -8497.2693   -8497.2693    308.59113    308.59113    23684.987    23684.987    3534.6346    3534.6346 
Loop time of 136.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.633 ns/day, 37.914 hours/ns, 7.327 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    | 135.98     | 135.98     | 135.98     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095853   | 0.095853   | 0.095853   |   0.0 |  0.07
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.35152    | 0.35152    | 0.35152    |   0.0 |  0.26
Other   |            | 0.05913    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128068.0 ave      128068 max      128068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128068
Ave neighs/atom = 64.034000
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.011370379496, Press = 1.37233874819548
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8417.5321   -8417.5321   -8497.2693   -8497.2693    308.59113    308.59113    23684.987    23684.987    3534.6346    3534.6346 
   34000   -8414.0144   -8414.0144   -8496.7981   -8496.7981    320.38122    320.38122    23723.403    23723.403    974.64838    974.64838 
Loop time of 136.625 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.632 ns/day, 37.951 hours/ns, 7.319 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    | 136.12     | 136.12     | 136.12     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095504   | 0.095504   | 0.095504   |   0.0 |  0.07
Output  | 0.00015555 | 0.00015555 | 0.00015555 |   0.0 |  0.00
Modify  | 0.3529     | 0.3529     | 0.3529     |   0.0 |  0.26
Other   |            | 0.05881    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128098.0 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049000
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.020882174165, Press = 0.261556324696758
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8414.0144   -8414.0144   -8496.7981   -8496.7981    320.38122    320.38122    23723.403    23723.403    974.64838    974.64838 
   35000   -8417.0636   -8417.0636   -8496.1928   -8496.1928    306.23802    306.23802    23737.018    23737.018   -25.670771   -25.670771 
Loop time of 135.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.742 hours/ns, 7.360 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    | 135.37     | 135.37     | 135.37     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095373   | 0.095373   | 0.095373   |   0.0 |  0.07
Output  | 0.00015311 | 0.00015311 | 0.00015311 |   0.0 |  0.00
Modify  | 0.35123    | 0.35123    | 0.35123    |   0.0 |  0.26
Other   |            | 0.05877    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128060.0 ave      128060 max      128060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128060
Ave neighs/atom = 64.030000
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.033095561822, Press = 1.0006902231955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8417.0636   -8417.0636   -8496.1928   -8496.1928    306.23802    306.23802    23737.018    23737.018   -25.670771   -25.670771 
   36000   -8414.2705   -8414.2705   -8495.0091   -8495.0091    312.46686    312.46686    23742.861    23742.861   -141.10401   -141.10401 
Loop time of 137.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.629 ns/day, 38.150 hours/ns, 7.281 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    | 136.83     | 136.83     | 136.83     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095707   | 0.095707   | 0.095707   |   0.0 |  0.07
Output  | 0.00015254 | 0.00015254 | 0.00015254 |   0.0 |  0.00
Modify  | 0.35254    | 0.35254    | 0.35254    |   0.0 |  0.26
Other   |            | 0.05952    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128032.0 ave      128032 max      128032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128032
Ave neighs/atom = 64.016000
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.022768036092, Press = 1.14347405090484
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8414.2705   -8414.2705   -8495.0091   -8495.0091    312.46686    312.46686    23742.861    23742.861   -141.10401   -141.10401 
   37000   -8417.7807   -8417.7807    -8497.175    -8497.175    307.26392    307.26392    23741.571    23741.571   -538.29338   -538.29338 
Loop time of 135.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.750 hours/ns, 7.358 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    | 135.4      | 135.4      | 135.4      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093989   | 0.093989   | 0.093989   |   0.0 |  0.07
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.34878    | 0.34878    | 0.34878    |   0.0 |  0.26
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:        4118.00 ave        4118 max        4118 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:      128044.0 ave      128044 max      128044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128044
Ave neighs/atom = 64.022000
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.935040388012, Press = 1.37742555433158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8417.7807   -8417.7807    -8497.175    -8497.175    307.26392    307.26392    23741.571    23741.571   -538.29338   -538.29338 
   38000   -8415.5505   -8415.5505   -8495.7258   -8495.7258    310.28663    310.28663    23737.288    23737.288    91.021019    91.021019 
Loop time of 135.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.744 hours/ns, 7.359 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    | 135.38     | 135.38     | 135.38     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094227   | 0.094227   | 0.094227   |   0.0 |  0.07
Output  | 0.00015529 | 0.00015529 | 0.00015529 |   0.0 |  0.00
Modify  | 0.34846    | 0.34846    | 0.34846    |   0.0 |  0.26
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:        4117.00 ave        4117 max        4117 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:      128070.0 ave      128070 max      128070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128070
Ave neighs/atom = 64.035000
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.972308492674, Press = 2.08842325190568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8415.5505   -8415.5505   -8495.7258   -8495.7258    310.28663    310.28663    23737.288    23737.288    91.021019    91.021019 
   39000   -8417.8357   -8417.8357   -8496.1108   -8496.1108    302.93269    302.93269    23723.573    23723.573    1005.3156    1005.3156 
Loop time of 136.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.635 ns/day, 37.823 hours/ns, 7.344 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    | 135.66     | 135.66     | 135.66     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094475   | 0.094475   | 0.094475   |   0.0 |  0.07
Output  | 0.00015363 | 0.00015363 | 0.00015363 |   0.0 |  0.00
Modify  | 0.35021    | 0.35021    | 0.35021    |   0.0 |  0.26
Other   |            | 0.05989    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 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:      128058.0 ave      128058 max      128058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128058
Ave neighs/atom = 64.029000
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.993619442691, Press = 2.27655258062873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8417.8357   -8417.8357   -8496.1108   -8496.1108    302.93269    302.93269    23723.573    23723.573    1005.3156    1005.3156 
   40000   -8414.3539   -8414.3539    -8497.079    -8497.079    320.15438    320.15438    23702.887    23702.887    2349.5198    2349.5198 
Loop time of 135.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.655 hours/ns, 7.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.05     | 135.05     | 135.05     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094163   | 0.094163   | 0.094163   |   0.0 |  0.07
Output  | 0.00015307 | 0.00015307 | 0.00015307 |   0.0 |  0.00
Modify  | 0.34891    | 0.34891    | 0.34891    |   0.0 |  0.26
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:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128078.0 ave      128078 max      128078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128078
Ave neighs/atom = 64.039000
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.008855998333, Press = 2.16160424033361
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8414.3539   -8414.3539    -8497.079    -8497.079    320.15438    320.15438    23702.887    23702.887    2349.5198    2349.5198 
   41000   -8414.6429   -8414.6429   -8495.5971   -8495.5971    313.30104    313.30104    23687.345    23687.345     3759.416     3759.416 
Loop time of 136.158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.635 ns/day, 37.822 hours/ns, 7.344 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    | 135.66     | 135.66     | 135.66     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093748   | 0.093748   | 0.093748   |   0.0 |  0.07
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.34944    | 0.34944    | 0.34944    |   0.0 |  0.26
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:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128096.0 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048000
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.01175562035, Press = 0.737898457738949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8414.6429   -8414.6429   -8495.5971   -8495.5971    313.30104    313.30104    23687.345    23687.345     3759.416     3759.416 
   42000   -8416.6415   -8416.6415   -8496.3337   -8496.3337    308.41725    308.41725    23711.608    23711.608    1810.9741    1810.9741 
Loop time of 136.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.024 hours/ns, 7.305 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    | 136.38     | 136.38     | 136.38     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094338   | 0.094338   | 0.094338   |   0.0 |  0.07
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.35166    | 0.35166    | 0.35166    |   0.0 |  0.26
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:        4115.00 ave        4115 max        4115 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:      128052.0 ave      128052 max      128052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128052
Ave neighs/atom = 64.026000
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.004912618947, Press = -0.24850612964231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8416.6415   -8416.6415   -8496.3337   -8496.3337    308.41725    308.41725    23711.608    23711.608    1810.9741    1810.9741 
   43000   -8415.1517   -8415.1517   -8498.3668   -8498.3668    322.05116    322.05116    23738.974    23738.974   -373.02621   -373.02621 
Loop time of 135.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.735 hours/ns, 7.361 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    | 135.34     | 135.34     | 135.34     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094979   | 0.094979   | 0.094979   |   0.0 |  0.07
Output  | 0.00016386 | 0.00016386 | 0.00016386 |   0.0 |  0.00
Modify  | 0.34966    | 0.34966    | 0.34966    |   0.0 |  0.26
Other   |            | 0.0595     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4115.00 ave        4115 max        4115 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:      128084.0 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042000
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.910686366074, Press = -0.0772677734724221
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8415.1517   -8415.1517   -8498.3668   -8498.3668    322.05116    322.05116    23738.974    23738.974   -373.02621   -373.02621 
   44000   -8413.3128   -8413.3128   -8495.5482   -8495.5482    318.25966    318.25966    23755.693    23755.693   -1091.4346   -1091.4346 
Loop time of 135.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.638 hours/ns, 7.380 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    | 135        | 135        | 135        |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094095   | 0.094095   | 0.094095   |   0.0 |  0.07
Output  | 0.00015263 | 0.00015263 | 0.00015263 |   0.0 |  0.00
Modify  | 0.34869    | 0.34869    | 0.34869    |   0.0 |  0.26
Other   |            | 0.05924    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128038.0 ave      128038 max      128038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128038
Ave neighs/atom = 64.019000
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.930299016095, Press = 0.0033460703593817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8413.3128   -8413.3128   -8495.5482   -8495.5482    318.25966    318.25966    23755.693    23755.693   -1091.4346   -1091.4346 
   45000    -8414.674    -8414.674   -8496.7367   -8496.7367     317.5912     317.5912      23766.1      23766.1   -2095.6372   -2095.6372 
Loop time of 136.365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.879 hours/ns, 7.333 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    | 135.86     | 135.86     | 135.86     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094419   | 0.094419   | 0.094419   |   0.0 |  0.07
Output  | 0.00019714 | 0.00019714 | 0.00019714 |   0.0 |  0.00
Modify  | 0.35102    | 0.35102    | 0.35102    |   0.0 |  0.26
Other   |            | 0.05887    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128082.0 ave      128082 max      128082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128082
Ave neighs/atom = 64.041000
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.953904591497, Press = 1.03077626376375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -8414.674    -8414.674   -8496.7367   -8496.7367     317.5912     317.5912      23766.1      23766.1   -2095.6372   -2095.6372 
   46000   -8411.4253   -8411.4253   -8493.2309   -8493.2309    316.59624    316.59624    23797.611    23797.611   -3587.1962   -3587.1962 
Loop time of 136.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.841 hours/ns, 7.341 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    | 135.73     | 135.73     | 135.73     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093869   | 0.093869   | 0.093869   |   0.0 |  0.07
Output  | 0.00019768 | 0.00019768 | 0.00019768 |   0.0 |  0.00
Modify  | 0.34917    | 0.34917    | 0.34917    |   0.0 |  0.26
Other   |            | 0.05976    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128066.0 ave      128066 max      128066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128066
Ave neighs/atom = 64.033000
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.024728470768, Press = 2.59149619522957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8411.4253   -8411.4253   -8493.2309   -8493.2309    316.59624    316.59624    23797.611    23797.611   -3587.1962   -3587.1962 
   47000   -8413.8917   -8413.8917   -8495.7049   -8495.7049     316.6256     316.6256    23752.133    23752.133   -843.34983   -843.34983 
Loop time of 135.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.649 hours/ns, 7.378 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    | 135.03     | 135.03     | 135.03     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093578   | 0.093578   | 0.093578   |   0.0 |  0.07
Output  | 0.0001955  | 0.0001955  | 0.0001955  |   0.0 |  0.00
Modify  | 0.3491     | 0.3491     | 0.3491     |   0.0 |  0.26
Other   |            | 0.05916    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 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:      128002.0 ave      128002 max      128002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128002
Ave neighs/atom = 64.001000
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.050070002651, Press = 3.20307515850504
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8413.8917   -8413.8917   -8495.7049   -8495.7049     316.6256     316.6256    23752.133    23752.133   -843.34983   -843.34983 
   48000   -8417.8627   -8417.8627   -8497.0754   -8497.0754     306.5611     306.5611    23727.104    23727.104    555.81274    555.81274 
Loop time of 135.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.699 hours/ns, 7.368 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    | 135.22     | 135.22     | 135.22     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094024   | 0.094024   | 0.094024   |   0.0 |  0.07
Output  | 0.00015839 | 0.00015839 | 0.00015839 |   0.0 |  0.00
Modify  | 0.34948    | 0.34948    | 0.34948    |   0.0 |  0.26
Other   |            | 0.05853    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128024.0 ave      128024 max      128024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128024
Ave neighs/atom = 64.012000
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.093375432004, Press = 1.99376513156115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8417.8627   -8417.8627   -8497.0754   -8497.0754     306.5611     306.5611    23727.104    23727.104    555.81274    555.81274 
   49000   -8413.6438   -8413.6438   -8496.7426   -8496.7426    321.60077    321.60077    23728.171    23728.171    724.90913    724.90913 
Loop time of 135.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.656 hours/ns, 7.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.06     | 135.06     | 135.06     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094583   | 0.094583   | 0.094583   |   0.0 |  0.07
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.3492     | 0.3492     | 0.3492     |   0.0 |  0.26
Other   |            | 0.05885    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128050.0 ave      128050 max      128050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128050
Ave neighs/atom = 64.025000
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.062402034449, Press = 1.56317757045427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8413.6438   -8413.6438   -8496.7426   -8496.7426    321.60077    321.60077    23728.171    23728.171    724.90913    724.90913 
   50000   -8418.1533   -8418.1533   -8496.4482   -8496.4482    303.00935    303.00935    23712.924    23712.924    1644.2213    1644.2213 
Loop time of 135.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.643 hours/ns, 7.379 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    | 135.01     | 135.01     | 135.01     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094305   | 0.094305   | 0.094305   |   0.0 |  0.07
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.34848    | 0.34848    | 0.34848    |   0.0 |  0.26
Other   |            | 0.05851    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128040.0 ave      128040 max      128040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128040
Ave neighs/atom = 64.020000
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.997095283862, Press = 1.03708266287489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8418.1533   -8418.1533   -8496.4482   -8496.4482    303.00935    303.00935    23712.924    23712.924    1644.2213    1644.2213 
   51000   -8414.5736   -8414.5736   -8494.7841   -8494.7841    310.42288    310.42288    23691.699    23691.699    3552.0619    3552.0619 
Loop time of 135.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.692 hours/ns, 7.370 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    | 135.19     | 135.19     | 135.19     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093833   | 0.093833   | 0.093833   |   0.0 |  0.07
Output  | 0.00015274 | 0.00015274 | 0.00015274 |   0.0 |  0.00
Modify  | 0.34964    | 0.34964    | 0.34964    |   0.0 |  0.26
Other   |            | 0.05919    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128056.0 ave      128056 max      128056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128056
Ave neighs/atom = 64.028000
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
23739.4270349933

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0