# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.024436 33.024436 33.024436)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.024436 33.024436 33.024436)
  create_atoms CPU = 0.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_KimJungLee_2010_FeNbC__MO_072689718616_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

variable temp_converted equal 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

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

Performance: 0.755 ns/day, 31.804 hours/ns, 8.734 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    | 114.01     | 114.01     | 114.01     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076068   | 0.076068   | 0.076068   |   0.0 |  0.07
Output  | 0.00019723 | 0.00019723 | 0.00019723 |   0.0 |  0.00
Modify  | 0.35335    | 0.35335    | 0.35335    |   0.0 |  0.31
Other   |            | 0.0567     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.679 ns/day, 35.357 hours/ns, 7.856 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.78     | 126.78     | 126.78     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084594   | 0.084594   | 0.084594   |   0.0 |  0.07
Output  | 0.00019154 | 0.00019154 | 0.00019154 |   0.0 |  0.00
Modify  | 0.36134    | 0.36134    | 0.36134    |   0.0 |  0.28
Other   |            | 0.05976    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3362.00 ave        3362 max        3362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121044.0 ave      121044 max      121044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121044
Ave neighs/atom = 60.522000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -14806.405   -14806.405   -14869.358   -14869.358    243.63317    243.63317    36172.695    36172.695    152.73472    152.73472 
    3000   -14809.709   -14809.709   -14872.238   -14872.238    241.99472    241.99472    36154.021    36154.021    720.14729    720.14729 
Loop time of 127.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.676 ns/day, 35.500 hours/ns, 7.825 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.29     | 127.29     | 127.29     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083891   | 0.083891   | 0.083891   |   0.0 |  0.07
Output  | 0.00019355 | 0.00019355 | 0.00019355 |   0.0 |  0.00
Modify  | 0.36431    | 0.36431    | 0.36431    |   0.0 |  0.29
Other   |            | 0.05955    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3334.00 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121008.0 ave      121008 max      121008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121008
Ave neighs/atom = 60.504000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -14809.709   -14809.709   -14872.238   -14872.238    241.99472    241.99472    36154.021    36154.021    720.14729    720.14729 
    4000   -14806.074   -14806.074   -14870.705   -14870.705    250.12935    250.12935     36147.02     36147.02    1394.9562    1394.9562 
Loop time of 127.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.538 hours/ns, 7.816 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    | 127.43     | 127.43     | 127.43     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084438   | 0.084438   | 0.084438   |   0.0 |  0.07
Output  | 0.00035284 | 0.00035284 | 0.00035284 |   0.0 |  0.00
Modify  | 0.36524    | 0.36524    | 0.36524    |   0.0 |  0.29
Other   |            | 0.05947    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3347.00 ave        3347 max        3347 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121166.0 ave      121166 max      121166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121166
Ave neighs/atom = 60.583000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -14806.074   -14806.074   -14870.705   -14870.705    250.12935    250.12935     36147.02     36147.02    1394.9562    1394.9562 
    5000   -14809.601   -14809.601   -14874.301   -14874.301    250.39798    250.39798    36197.335    36197.335   -1601.5022   -1601.5022 
Loop time of 128.013 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.559 hours/ns, 7.812 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.5      | 127.5      | 127.5      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085278   | 0.085278   | 0.085278   |   0.0 |  0.07
Output  | 0.00015645 | 0.00015645 | 0.00015645 |   0.0 |  0.00
Modify  | 0.36651    | 0.36651    | 0.36651    |   0.0 |  0.29
Other   |            | 0.05959    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3354.00 ave        3354 max        3354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121170.0 ave      121170 max      121170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121170
Ave neighs/atom = 60.585000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.218770795681, Press = 116.804518525813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -14809.601   -14809.601   -14874.301   -14874.301    250.39798    250.39798    36197.335    36197.335   -1601.5022   -1601.5022 
    6000   -14807.797   -14807.797   -14875.468   -14875.468    261.89225    261.89225    36191.259    36191.259   -1385.8678   -1385.8678 
Loop time of 126.172 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.048 hours/ns, 7.926 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    | 125.65     | 125.65     | 125.65     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08547    | 0.08547    | 0.08547    |   0.0 |  0.07
Output  | 0.00015529 | 0.00015529 | 0.00015529 |   0.0 |  0.00
Modify  | 0.37821    | 0.37821    | 0.37821    |   0.0 |  0.30
Other   |            | 0.05947    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3420.00 ave        3420 max        3420 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120984.0 ave      120984 max      120984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120984
Ave neighs/atom = 60.492000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.834805006309, Press = 44.9875623530697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -14807.797   -14807.797   -14875.468   -14875.468    261.89225    261.89225    36191.259    36191.259   -1385.8678   -1385.8678 
    7000   -14806.134   -14806.134   -14872.838   -14872.838    258.15025    258.15025    36133.968    36133.968    1865.9775    1865.9775 
Loop time of 126.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.097 hours/ns, 7.915 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    | 125.83     | 125.83     | 125.83     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085271   | 0.085271   | 0.085271   |   0.0 |  0.07
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.37809    | 0.37809    | 0.37809    |   0.0 |  0.30
Other   |            | 0.05932    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3402.00 ave        3402 max        3402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120908.0 ave      120908 max      120908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120908
Ave neighs/atom = 60.454000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.751592105354, Press = 26.1113437707978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -14806.134   -14806.134   -14872.838   -14872.838    258.15025    258.15025    36133.968    36133.968    1865.9775    1865.9775 
    8000   -14807.706   -14807.706   -14871.347   -14871.347    246.29909    246.29909    36139.231    36139.231    1606.6232    1606.6232 
Loop time of 127.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.395 hours/ns, 7.848 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.89     | 126.89     | 126.89     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086547   | 0.086547   | 0.086547   |   0.0 |  0.07
Output  | 0.0001585  | 0.0001585  | 0.0001585  |   0.0 |  0.00
Modify  | 0.38238    | 0.38238    | 0.38238    |   0.0 |  0.30
Other   |            | 0.0594     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3445.00 ave        3445 max        3445 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121066.0 ave      121066 max      121066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121066
Ave neighs/atom = 60.533000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.460733775021, Press = -2.74152519914247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -14807.706   -14807.706   -14871.347   -14871.347    246.29909    246.29909    36139.231    36139.231    1606.6232    1606.6232 
    9000   -14806.737   -14806.737   -14874.259   -14874.259    261.31831    261.31831    36197.643    36197.643   -1587.0934   -1587.0934 
Loop time of 127.431 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.397 hours/ns, 7.847 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.9      | 126.9      | 126.9      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085858   | 0.085858   | 0.085858   |   0.0 |  0.07
Output  | 0.00018967 | 0.00018967 | 0.00018967 |   0.0 |  0.00
Modify  | 0.38057    | 0.38057    | 0.38057    |   0.0 |  0.30
Other   |            | 0.05964    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3352.00 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121234.0 ave      121234 max      121234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121234
Ave neighs/atom = 60.617000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.309718868203, Press = 3.99755927601003
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -14806.737   -14806.737   -14874.259   -14874.259    261.31831    261.31831    36197.643    36197.643   -1587.0934   -1587.0934 
   10000   -14807.352   -14807.352   -14875.467   -14875.467    263.61022    263.61022     36174.07     36174.07   -347.27637   -347.27637 
Loop time of 126.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.208 hours/ns, 7.890 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.23     | 126.23     | 126.23     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083711   | 0.083711   | 0.083711   |   0.0 |  0.07
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.37771    | 0.37771    | 0.37771    |   0.0 |  0.30
Other   |            | 0.05923    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3352.00 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120880.0 ave      120880 max      120880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120880
Ave neighs/atom = 60.440000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.756558279334, Press = 9.32721818100171
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -14807.352   -14807.352   -14875.467   -14875.467    263.61022    263.61022     36174.07     36174.07   -347.27637   -347.27637 
   11000   -14806.016   -14806.016   -14873.225   -14873.225    260.10647    260.10647    36148.305    36148.305    1235.3167    1235.3167 
Loop time of 124.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.718 hours/ns, 8.001 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.47     | 124.47     | 124.47     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083286   | 0.083286   | 0.083286   |   0.0 |  0.07
Output  | 0.00015718 | 0.00015718 | 0.00015718 |   0.0 |  0.00
Modify  | 0.37275    | 0.37275    | 0.37275    |   0.0 |  0.30
Other   |            | 0.05886    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120922.0 ave      120922 max      120922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120922
Ave neighs/atom = 60.461000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.591393333483, Press = 3.9529389871035
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -14806.016   -14806.016   -14873.225   -14873.225    260.10647    260.10647    36148.305    36148.305    1235.3167    1235.3167 
   12000   -14807.773   -14807.773   -14872.283   -14872.283    249.66012    249.66012    36188.828    36188.828   -1042.5885   -1042.5885 
Loop time of 125.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.894 hours/ns, 7.961 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    | 125.1      | 125.1      | 125.1      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085586   | 0.085586   | 0.085586   |   0.0 |  0.07
Output  | 0.00015265 | 0.00015265 | 0.00015265 |   0.0 |  0.00
Modify  | 0.3776     | 0.3776     | 0.3776     |   0.0 |  0.30
Other   |            | 0.05957    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3381.00 ave        3381 max        3381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121066.0 ave      121066 max      121066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121066
Ave neighs/atom = 60.533000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.30445503993, Press = 2.18044800889739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -14807.773   -14807.773   -14872.283   -14872.283    249.66012    249.66012    36188.828    36188.828   -1042.5885   -1042.5885 
   13000   -14807.975   -14807.975   -14872.142   -14872.142    248.33219    248.33219    36173.199    36173.199   -200.16103   -200.16103 
Loop time of 126.628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.174 hours/ns, 7.897 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.1      | 126.1      | 126.1      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086268   | 0.086268   | 0.086268   |   0.0 |  0.07
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.38067    | 0.38067    | 0.38067    |   0.0 |  0.30
Other   |            | 0.05924    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3409.00 ave        3409 max        3409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121038.0 ave      121038 max      121038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121038
Ave neighs/atom = 60.519000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 254.210472204782, Press = 6.09737200080353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -14807.975   -14807.975   -14872.142   -14872.142    248.33219    248.33219    36173.199    36173.199   -200.16103   -200.16103 
   14000   -14810.679   -14810.679   -14873.551   -14873.551    243.32111    243.32111    36138.168    36138.168    1552.5968    1552.5968 
Loop time of 124.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.683 hours/ns, 8.009 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    | 124.34     | 124.34     | 124.34     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085938   | 0.085938   | 0.085938   |   0.0 |  0.07
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.37381    | 0.37381    | 0.37381    |   0.0 |  0.30
Other   |            | 0.05937    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3438.00 ave        3438 max        3438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121070.0 ave      121070 max      121070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121070
Ave neighs/atom = 60.535000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.7795691469, Press = 4.36962885048182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -14810.679   -14810.679   -14873.551   -14873.551    243.32111    243.32111    36138.168    36138.168    1552.5968    1552.5968 
   15000   -14807.318   -14807.318   -14874.158   -14874.158    258.67872    258.67872    36162.028    36162.028    304.87981    304.87981 
Loop time of 124.305 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.529 hours/ns, 8.045 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    | 123.79     | 123.79     | 123.79     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083926   | 0.083926   | 0.083926   |   0.0 |  0.07
Output  | 0.00044526 | 0.00044526 | 0.00044526 |   0.0 |  0.00
Modify  | 0.36915    | 0.36915    | 0.36915    |   0.0 |  0.30
Other   |            | 0.05881    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3401.00 ave        3401 max        3401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121114.0 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.614871469009, Press = -0.340939072015496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -14807.318   -14807.318   -14874.158   -14874.158    258.67872    258.67872    36162.028    36162.028    304.87981    304.87981 
   16000   -14809.298   -14809.298   -14875.738   -14875.738    257.13136    257.13136    36227.943    36227.943   -3358.6492   -3358.6492 
Loop time of 124.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.717 hours/ns, 8.001 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    | 124.47     | 124.47     | 124.47     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083603   | 0.083603   | 0.083603   |   0.0 |  0.07
Output  | 0.00016288 | 0.00016288 | 0.00016288 |   0.0 |  0.00
Modify  | 0.37306    | 0.37306    | 0.37306    |   0.0 |  0.30
Other   |            | 0.05893    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3346.00 ave        3346 max        3346 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121100.0 ave      121100 max      121100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121100
Ave neighs/atom = 60.550000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.353911476775, Press = 2.4262324384167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -14809.298   -14809.298   -14875.738   -14875.738    257.13136    257.13136    36227.943    36227.943   -3358.6492   -3358.6492 
   17000   -14809.289   -14809.289   -14874.641   -14874.641    252.91975    252.91975    36153.761    36153.761    653.77685    653.77685 
Loop time of 125.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.757 hours/ns, 7.992 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.61     | 124.61     | 124.61     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082805   | 0.082805   | 0.082805   |   0.0 |  0.07
Output  | 0.00015414 | 0.00015414 | 0.00015414 |   0.0 |  0.00
Modify  | 0.37179    | 0.37179    | 0.37179    |   0.0 |  0.30
Other   |            | 0.05837    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3293.00 ave        3293 max        3293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120778.0 ave      120778 max      120778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120778
Ave neighs/atom = 60.389000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.360222556963, Press = 5.44621253466033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -14809.289   -14809.289   -14874.641   -14874.641    252.91975    252.91975    36153.761    36153.761    653.77685    653.77685 
   18000   -14809.266   -14809.266   -14871.905   -14871.905    242.41848    242.41848    36149.834    36149.834    1006.3687    1006.3687 
Loop time of 126.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.161 hours/ns, 7.900 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.05     | 126.05     | 126.05     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085058   | 0.085058   | 0.085058   |   0.0 |  0.07
Output  | 0.00019366 | 0.00019366 | 0.00019366 |   0.0 |  0.00
Modify  | 0.38       | 0.38       | 0.38       |   0.0 |  0.30
Other   |            | 0.05967    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3366.00 ave        3366 max        3366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121172.0 ave      121172 max      121172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121172
Ave neighs/atom = 60.586000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.336294343485, Press = 2.12042965184283
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -14809.266   -14809.266   -14871.905   -14871.905    242.41848    242.41848    36149.834    36149.834    1006.3687    1006.3687 
   19000   -14806.434   -14806.434   -14871.704   -14871.704    252.60255    252.60255    36184.687    36184.687   -730.42497   -730.42497 
Loop time of 127.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.409 hours/ns, 7.845 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.94     | 126.94     | 126.94     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086048   | 0.086048   | 0.086048   |   0.0 |  0.07
Output  | 0.00018958 | 0.00018958 | 0.00018958 |   0.0 |  0.00
Modify  | 0.38458    | 0.38458    | 0.38458    |   0.0 |  0.30
Other   |            | 0.05955    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3397.00 ave        3397 max        3397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121026.0 ave      121026 max      121026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121026
Ave neighs/atom = 60.513000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.414067165729, Press = 1.31186334223016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -14806.434   -14806.434   -14871.704   -14871.704    252.60255    252.60255    36184.687    36184.687   -730.42497   -730.42497 
   20000   -14808.471   -14808.471   -14872.153   -14872.153    246.45869    246.45869    36181.586    36181.586   -697.51012   -697.51012 
Loop time of 126.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.087 hours/ns, 7.917 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    | 125.79     | 125.79     | 125.79     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084467   | 0.084467   | 0.084467   |   0.0 |  0.07
Output  | 0.00015773 | 0.00015773 | 0.00015773 |   0.0 |  0.00
Modify  | 0.3773     | 0.3773     | 0.3773     |   0.0 |  0.30
Other   |            | 0.05889    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3368.00 ave        3368 max        3368 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121022.0 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.488630887735, Press = 3.44692927590697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -14808.471   -14808.471   -14872.153   -14872.153    246.45869    246.45869    36181.586    36181.586   -697.51012   -697.51012 
   21000   -14803.263   -14803.263   -14870.786   -14870.786    261.32286    261.32286    36121.724    36121.724    2785.2001    2785.2001 
Loop time of 125.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.786 hours/ns, 7.985 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.72     | 124.72     | 124.72     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084315   | 0.084315   | 0.084315   |   0.0 |  0.07
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.37113    | 0.37113    | 0.37113    |   0.0 |  0.30
Other   |            | 0.05853    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3381.00 ave        3381 max        3381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.556850829177, Press = 3.25613223675701
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -14803.263   -14803.263   -14870.786   -14870.786    261.32286    261.32286    36121.724    36121.724    2785.2001    2785.2001 
   22000   -14808.502   -14808.502   -14874.323   -14874.323    254.73627    254.73627    36166.213    36166.213    2.0047309    2.0047309 
Loop time of 127.083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.301 hours/ns, 7.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.56     | 126.56     | 126.56     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085794   | 0.085794   | 0.085794   |   0.0 |  0.07
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.38225    | 0.38225    | 0.38225    |   0.0 |  0.30
Other   |            | 0.05908    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3398.00 ave        3398 max        3398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121232.0 ave      121232 max      121232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121232
Ave neighs/atom = 60.616000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.63397039302, Press = -0.725722689221591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -14808.502   -14808.502   -14874.323   -14874.323    254.73627    254.73627    36166.213    36166.213    2.0047309    2.0047309 
   23000   -14806.611   -14806.611   -14871.558   -14871.558    251.35354    251.35354    36189.456    36189.456   -1043.4488   -1043.4488 
Loop time of 124.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.716 hours/ns, 8.001 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    | 124.46     | 124.46     | 124.46     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084055   | 0.084055   | 0.084055   |   0.0 |  0.07
Output  | 0.00019307 | 0.00019307 | 0.00019307 |   0.0 |  0.00
Modify  | 0.3718     | 0.3718     | 0.3718     |   0.0 |  0.30
Other   |            | 0.05879    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3377.00 ave        3377 max        3377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121038.0 ave      121038 max      121038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121038
Ave neighs/atom = 60.519000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.660546786021, Press = 1.71824544112255
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -14806.611   -14806.611   -14871.558   -14871.558    251.35354    251.35354    36189.456    36189.456   -1043.4488   -1043.4488 
   24000   -14811.028   -14811.028   -14872.443   -14872.443    237.68486    237.68486    36149.927    36149.927    896.76983    896.76983 
Loop time of 126.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.002 hours/ns, 7.936 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    | 125.49     | 125.49     | 125.49     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084695   | 0.084695   | 0.084695   |   0.0 |  0.07
Output  | 0.00015575 | 0.00015575 | 0.00015575 |   0.0 |  0.00
Modify  | 0.37451    | 0.37451    | 0.37451    |   0.0 |  0.30
Other   |            | 0.05916    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3373.00 ave        3373 max        3373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120988.0 ave      120988 max      120988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120988
Ave neighs/atom = 60.494000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.571244527735, Press = 2.30236179157088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -14811.028   -14811.028   -14872.443   -14872.443    237.68486    237.68486    36149.927    36149.927    896.76983    896.76983 
   25000   -14806.107   -14806.107   -14871.835   -14871.835    254.37472    254.37472    36152.215    36152.215    986.09144    986.09144 
Loop time of 128.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.618 hours/ns, 7.799 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.69     | 127.69     | 127.69     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087043   | 0.087043   | 0.087043   |   0.0 |  0.07
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.38497    | 0.38497    | 0.38497    |   0.0 |  0.30
Other   |            | 0.05997    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3404.00 ave        3404 max        3404 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121106.0 ave      121106 max      121106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121106
Ave neighs/atom = 60.553000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.500894686917, Press = 0.759850081723514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -14806.107   -14806.107   -14871.835   -14871.835    254.37472    254.37472    36152.215    36152.215    986.09144    986.09144 
   26000   -14808.267   -14808.267   -14873.064   -14873.064    250.77032    250.77032    36213.554    36213.554   -2433.7064   -2433.7064 
Loop time of 127.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.345 hours/ns, 7.859 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.72     | 126.72     | 126.72     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08513    | 0.08513    | 0.08513    |   0.0 |  0.07
Output  | 0.00021718 | 0.00021718 | 0.00021718 |   0.0 |  0.00
Modify  | 0.38156    | 0.38156    | 0.38156    |   0.0 |  0.30
Other   |            | 0.05937    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3349.00 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121114.0 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.522929462114, Press = 0.33890009930862
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -14808.267   -14808.267   -14873.064   -14873.064    250.77032    250.77032    36213.554    36213.554   -2433.7064   -2433.7064 
   27000   -14807.203   -14807.203    -14872.04    -14872.04    250.92504    250.92504    36176.842    36176.842   -392.25224   -392.25224 
Loop time of 127.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.455 hours/ns, 7.835 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.11     | 127.11     | 127.11     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084958   | 0.084958   | 0.084958   |   0.0 |  0.07
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.38429    | 0.38429    | 0.38429    |   0.0 |  0.30
Other   |            | 0.05976    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120858.0 ave      120858 max      120858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120858
Ave neighs/atom = 60.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.489837763053, Press = 4.11382278867257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -14807.203   -14807.203    -14872.04    -14872.04    250.92504    250.92504    36176.842    36176.842   -392.25224   -392.25224 
   28000   -14811.041   -14811.041   -14876.256   -14876.256    252.38626    252.38626     36123.21     36123.21    2114.5084    2114.5084 
Loop time of 126.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.149 hours/ns, 7.903 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.01     | 126.01     | 126.01     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084852   | 0.084852   | 0.084852   |   0.0 |  0.07
Output  | 0.00019737 | 0.00019737 | 0.00019737 |   0.0 |  0.00
Modify  | 0.38035    | 0.38035    | 0.38035    |   0.0 |  0.30
Other   |            | 0.05897    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3367.00 ave        3367 max        3367 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121054.0 ave      121054 max      121054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121054
Ave neighs/atom = 60.527000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.398164515648, Press = 1.70894097433552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -14811.041   -14811.041   -14876.256   -14876.256    252.38626    252.38626     36123.21     36123.21    2114.5084    2114.5084 
   29000   -14808.817   -14808.817    -14874.71    -14874.71    255.01196    255.01196    36171.911    36171.911   -328.62734   -328.62734 
Loop time of 125.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 34.964 hours/ns, 7.945 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    | 125.35     | 125.35     | 125.35     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084821   | 0.084821   | 0.084821   |   0.0 |  0.07
Output  | 0.00015728 | 0.00015728 | 0.00015728 |   0.0 |  0.00
Modify  | 0.37253    | 0.37253    | 0.37253    |   0.0 |  0.30
Other   |            | 0.0587     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3386.00 ave        3386 max        3386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121140.0 ave      121140 max      121140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121140
Ave neighs/atom = 60.570000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.399713102361, Press = 0.0848320457014916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -14808.817   -14808.817    -14874.71    -14874.71    255.01196    255.01196    36171.911    36171.911   -328.62734   -328.62734 
   30000   -14806.225   -14806.225   -14872.323   -14872.323    255.80523    255.80523    36201.262    36201.262   -1631.5911   -1631.5911 
Loop time of 125.558 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.877 hours/ns, 7.964 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    | 125.04     | 125.04     | 125.04     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084706   | 0.084706   | 0.084706   |   0.0 |  0.07
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.37451    | 0.37451    | 0.37451    |   0.0 |  0.30
Other   |            | 0.05881    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3376.00 ave        3376 max        3376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121022.0 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.367350683398, Press = 1.43166357229431
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -14806.225   -14806.225   -14872.323   -14872.323    255.80523    255.80523    36201.262    36201.262   -1631.5911   -1631.5911 
   31000   -14812.507   -14812.507    -14875.47    -14875.47    243.67503    243.67503    36148.862    36148.862    772.69808    772.69808 
Loop time of 126.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.119 hours/ns, 7.910 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.9      | 125.9      | 125.9      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086014   | 0.086014   | 0.086014   |   0.0 |  0.07
Output  | 0.00020029 | 0.00020029 | 0.00020029 |   0.0 |  0.00
Modify  | 0.3786     | 0.3786     | 0.3786     |   0.0 |  0.30
Other   |            | 0.05932    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3397.00 ave        3397 max        3397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120840.0 ave      120840 max      120840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120840
Ave neighs/atom = 60.420000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.327595955392, Press = 2.96975335402124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -14812.507   -14812.507    -14875.47    -14875.47    243.67503    243.67503    36148.862    36148.862    772.69808    772.69808 
   32000   -14805.769   -14805.769   -14871.988   -14871.988     256.2746     256.2746    36108.225    36108.225    3408.4072    3408.4072 
Loop time of 127.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.383 hours/ns, 7.851 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.85     | 126.85     | 126.85     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085416   | 0.085416   | 0.085416   |   0.0 |  0.07
Output  | 0.00015786 | 0.00015786 | 0.00015786 |   0.0 |  0.00
Modify  | 0.38582    | 0.38582    | 0.38582    |   0.0 |  0.30
Other   |            | 0.05988    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3352.00 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121090.0 ave      121090 max      121090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121090
Ave neighs/atom = 60.545000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 253.273872243172, Press = 0.405356479747581
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -14805.769   -14805.769   -14871.988   -14871.988     256.2746     256.2746    36108.225    36108.225    3408.4072    3408.4072 
   33000   -14808.912   -14808.912   -14873.049   -14873.049    248.21523    248.21523    36193.464    36193.464   -1403.9531   -1403.9531 
Loop time of 126.606 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.168 hours/ns, 7.899 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.08     | 126.08     | 126.08     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084673   | 0.084673   | 0.084673   |   0.0 |  0.07
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.37967    | 0.37967    | 0.37967    |   0.0 |  0.30
Other   |            | 0.05926    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3376.00 ave        3376 max        3376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      121348.0 ave      121348 max      121348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121348
Ave neighs/atom = 60.674000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
36168.554403247

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0