# 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 4.049998879432679*${_u_distance}
variable latticeconst_converted equal 4.049998879432679*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04999887943268
Lattice spacing in x,y,z = 4.0499989 4.0499989 4.0499989
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 (40.499989 40.499989 40.499989)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.499989 40.499989 40.499989)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_PascuetFernandez_2015_Al__MO_315820974149_001
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0698596988 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_315820974149_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13288.427   -13288.427    -13439.96    -13439.96       293.15       293.15     66430.07     66430.07    2436.4703    2436.4703 
    1000   -13113.188   -13113.188   -13270.562   -13270.562    304.45098    304.45098    68076.303    68076.303    -527.2093    -527.2093 
Loop time of 196.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.653 hours/ns, 5.083 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    | 195.82     | 195.82     | 195.82     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14845    | 0.14845    | 0.14845    |   0.0 |  0.08
Output  | 0.00023078 | 0.00023078 | 0.00023078 |   0.0 |  0.00
Modify  | 0.68449    | 0.68449    | 0.68449    |   0.0 |  0.35
Other   |            | 0.09937    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13113.188   -13113.188   -13270.562   -13270.562    304.45098    304.45098    68076.303    68076.303    -527.2093    -527.2093 
    2000   -13131.578   -13131.578   -13279.787   -13279.787    286.72093    286.72093    67880.454    67880.454    441.73106    441.73106 
Loop time of 201.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.921 hours/ns, 4.967 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    | 200.36     | 200.36     | 200.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15161    | 0.15161    | 0.15161    |   0.0 |  0.08
Output  | 0.00024777 | 0.00024777 | 0.00024777 |   0.0 |  0.00
Modify  | 0.70337    | 0.70337    | 0.70337    |   0.0 |  0.35
Other   |            | 0.1019     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320364.0 ave      320364 max      320364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320364
Ave neighs/atom = 80.091000
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13131.578   -13131.578   -13279.787   -13279.787    286.72093    286.72093    67880.454    67880.454    441.73106    441.73106 
    3000   -13122.272   -13122.272   -13273.816   -13273.816    293.17219    293.17219    67966.348    67966.348     183.1851     183.1851 
Loop time of 200.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.556 hours/ns, 5.000 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    | 199.06     | 199.06     | 199.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14951    | 0.14951    | 0.14951    |   0.0 |  0.07
Output  | 0.00021536 | 0.00021536 | 0.00021536 |   0.0 |  0.00
Modify  | 0.69391    | 0.69391    | 0.69391    |   0.0 |  0.35
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320682.0 ave      320682 max      320682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320682
Ave neighs/atom = 80.170500
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13122.272   -13122.272   -13273.816   -13273.816    293.17219    293.17219    67966.348    67966.348     183.1851     183.1851 
    4000   -13128.516   -13128.516   -13279.702   -13279.702    292.48085    292.48085    67966.024    67966.024   -343.14234   -343.14234 
Loop time of 200.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.725 hours/ns, 4.985 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    | 199.66     | 199.66     | 199.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15133    | 0.15133    | 0.15133    |   0.0 |  0.08
Output  | 0.0002165  | 0.0002165  | 0.0002165  |   0.0 |  0.00
Modify  | 0.70157    | 0.70157    | 0.70157    |   0.0 |  0.35
Other   |            | 0.1013     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320588.0 ave      320588 max      320588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320588
Ave neighs/atom = 80.147000
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13128.516   -13128.516   -13279.702   -13279.702    292.48085    292.48085    67966.024    67966.024   -343.14234   -343.14234 
    5000   -13121.865   -13121.865   -13275.129   -13275.129    296.50067    296.50067    67913.626    67913.626    565.03004    565.03004 
Loop time of 200.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.566 hours/ns, 4.999 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    | 199.09     | 199.09     | 199.09     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15024    | 0.15024    | 0.15024    |   0.0 |  0.08
Output  | 0.00030406 | 0.00030406 | 0.00030406 |   0.0 |  0.00
Modify  | 0.69618    | 0.69618    | 0.69618    |   0.0 |  0.35
Other   |            | 0.101      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320638.0 ave      320638 max      320638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320638
Ave neighs/atom = 80.159500
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 = 296.469444914006, Press = -46.4370770194251
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13121.865   -13121.865   -13275.129   -13275.129    296.50067    296.50067    67913.626    67913.626    565.03004    565.03004 
    6000   -13129.152   -13129.152   -13280.274   -13280.274    292.35563    292.35563      68041.2      68041.2   -1093.2565   -1093.2565 
Loop time of 200.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.794 hours/ns, 4.979 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    | 199.89     | 199.89     | 199.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14968    | 0.14968    | 0.14968    |   0.0 |  0.07
Output  | 0.00022248 | 0.00022248 | 0.00022248 |   0.0 |  0.00
Modify  | 0.71554    | 0.71554    | 0.71554    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320748.0 ave      320748 max      320748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320748
Ave neighs/atom = 80.187000
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 = 293.183152624458, Press = -13.2858155350303
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13129.152   -13129.152   -13280.274   -13280.274    292.35563    292.35563      68041.2      68041.2   -1093.2565   -1093.2565 
    7000   -13123.513   -13123.513    -13278.03    -13278.03     298.9244     298.9244     67904.83     67904.83    445.14984    445.14984 
Loop time of 197.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.937 hours/ns, 5.056 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    | 196.82     | 196.82     | 196.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14909    | 0.14909    | 0.14909    |   0.0 |  0.08
Output  | 0.00017969 | 0.00017969 | 0.00017969 |   0.0 |  0.00
Modify  | 0.70818    | 0.70818    | 0.70818    |   0.0 |  0.36
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320396.0 ave      320396 max      320396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320396
Ave neighs/atom = 80.099000
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 = 293.370429673149, Press = 18.0301150027856
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13123.513   -13123.513    -13278.03    -13278.03     298.9244     298.9244     67904.83     67904.83    445.14984    445.14984 
    8000   -13127.142   -13127.142   -13277.665   -13277.665    291.19615    291.19615    67948.661    67948.661   -18.188125   -18.188125 
Loop time of 200.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.600 hours/ns, 4.996 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    | 199.19     | 199.19     | 199.19     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14966    | 0.14966    | 0.14966    |   0.0 |  0.07
Output  | 0.00017898 | 0.00017898 | 0.00017898 |   0.0 |  0.00
Modify  | 0.72081    | 0.72081    | 0.72081    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320736.0 ave      320736 max      320736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320736
Ave neighs/atom = 80.184000
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 = 293.158723368084, Press = -13.2273426204122
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13127.142   -13127.142   -13277.665   -13277.665    291.19615    291.19615    67948.661    67948.661   -18.188125   -18.188125 
    9000   -13124.419   -13124.419   -13276.154   -13276.154    293.54042    293.54042    67990.181    67990.181   -226.48604   -226.48604 
Loop time of 201.339 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.928 hours/ns, 4.967 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    | 200.36     | 200.36     | 200.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15089    | 0.15089    | 0.15089    |   0.0 |  0.07
Output  | 0.00029093 | 0.00029093 | 0.00029093 |   0.0 |  0.00
Modify  | 0.7268     | 0.7268     | 0.7268     |   0.0 |  0.36
Other   |            | 0.1016     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320664.0 ave      320664 max      320664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320664
Ave neighs/atom = 80.166000
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 = 292.912119878964, Press = 4.79227795848227
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13124.419   -13124.419   -13276.154   -13276.154    293.54042    293.54042    67990.181    67990.181   -226.48604   -226.48604 
   10000    -13132.72    -13132.72   -13281.509   -13281.509    287.84221    287.84221    67846.888    67846.888    631.80836    631.80836 
Loop time of 200.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.717 hours/ns, 4.985 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    | 199.61     | 199.61     | 199.61     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15232    | 0.15232    | 0.15232    |   0.0 |  0.08
Output  | 0.00017699 | 0.00017699 | 0.00017699 |   0.0 |  0.00
Modify  | 0.72172    | 0.72172    | 0.72172    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320592.0 ave      320592 max      320592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320592
Ave neighs/atom = 80.148000
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 = 292.613615728036, Press = -1.45738518317229
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -13132.72    -13132.72   -13281.509   -13281.509    287.84221    287.84221    67846.888    67846.888    631.80836    631.80836 
   11000    -13126.05    -13126.05    -13274.58    -13274.58    287.34149    287.34149    68004.011    68004.011   -302.94985   -302.94985 
Loop time of 200.607 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.724 hours/ns, 4.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    | 199.64     | 199.64     | 199.64     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15026    | 0.15026    | 0.15026    |   0.0 |  0.07
Output  | 0.00017941 | 0.00017941 | 0.00017941 |   0.0 |  0.00
Modify  | 0.71769    | 0.71769    | 0.71769    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320860.0 ave      320860 max      320860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320860
Ave neighs/atom = 80.215000
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 = 292.555295936559, Press = 0.770863908031701
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -13126.05    -13126.05    -13274.58    -13274.58    287.34149    287.34149    68004.011    68004.011   -302.94985   -302.94985 
   12000   -13128.038   -13128.038   -13278.589   -13278.589    291.25154    291.25154     67864.16     67864.16    769.32194    769.32194 
Loop time of 199.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.439 hours/ns, 5.011 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    | 198.61     | 198.61     | 198.61     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15081    | 0.15081    | 0.15081    |   0.0 |  0.08
Output  | 0.00022514 | 0.00022514 | 0.00022514 |   0.0 |  0.00
Modify  | 0.71688    | 0.71688    | 0.71688    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320370.0 ave      320370 max      320370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320370
Ave neighs/atom = 80.092500
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 = 292.432714757886, Press = 1.08095891779444
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13128.038   -13128.038   -13278.589   -13278.589    291.25154    291.25154     67864.16     67864.16    769.32194    769.32194 
   13000   -13124.963   -13124.963   -13275.909   -13275.909    292.01555    292.01555    68037.618    68037.618   -763.05428   -763.05428 
Loop time of 198.035 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.010 hours/ns, 5.050 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    | 197.07     | 197.07     | 197.07     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14906    | 0.14906    | 0.14906    |   0.0 |  0.08
Output  | 0.00018184 | 0.00018184 | 0.00018184 |   0.0 |  0.00
Modify  | 0.71126    | 0.71126    | 0.71126    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320780.0 ave      320780 max      320780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320780
Ave neighs/atom = 80.195000
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 = 292.556119581483, Press = -3.35101608342258
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13124.963   -13124.963   -13275.909   -13275.909    292.01555    292.01555    68037.618    68037.618   -763.05428   -763.05428 
   14000   -13126.464   -13126.464   -13278.119   -13278.119    293.38739    293.38739    67884.376    67884.376    641.64471    641.64471 
Loop time of 197.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.934 hours/ns, 5.057 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    | 196.81     | 196.81     | 196.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14923    | 0.14923    | 0.14923    |   0.0 |  0.08
Output  | 0.00018379 | 0.00018379 | 0.00018379 |   0.0 |  0.00
Modify  | 0.70744    | 0.70744    | 0.70744    |   0.0 |  0.36
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320266.0 ave      320266 max      320266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320266
Ave neighs/atom = 80.066500
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 = 292.604603950062, Press = 5.4964521901848
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13126.464   -13126.464   -13278.119   -13278.119    293.38739    293.38739    67884.376    67884.376    641.64471    641.64471 
   15000    -13130.59    -13130.59   -13280.447   -13280.447    289.90813    289.90813    67902.831    67902.831    154.09439    154.09439 
Loop time of 197.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.905 hours/ns, 5.059 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    | 196.7      | 196.7      | 196.7      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14839    | 0.14839    | 0.14839    |   0.0 |  0.08
Output  | 0.00017902 | 0.00017902 | 0.00017902 |   0.0 |  0.00
Modify  | 0.70599    | 0.70599    | 0.70599    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320748.0 ave      320748 max      320748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320748
Ave neighs/atom = 80.187000
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 = 292.610810953901, Press = -3.37768283254652
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -13130.59    -13130.59   -13280.447   -13280.447    289.90813    289.90813    67902.831    67902.831    154.09439    154.09439 
   16000   -13123.498   -13123.498    -13276.35    -13276.35     295.7028     295.7028    67984.242    67984.242   -180.13622   -180.13622 
Loop time of 199.639 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.455 hours/ns, 5.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    | 198.67     | 198.67     | 198.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14891    | 0.14891    | 0.14891    |   0.0 |  0.07
Output  | 0.00022237 | 0.00022237 | 0.00022237 |   0.0 |  0.00
Modify  | 0.7198     | 0.7198     | 0.7198     |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320792.0 ave      320792 max      320792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320792
Ave neighs/atom = 80.198000
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 = 292.642656111244, Press = 1.92390754763613
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13123.498   -13123.498    -13276.35    -13276.35     295.7028     295.7028    67984.242    67984.242   -180.13622   -180.13622 
   17000    -13129.29    -13129.29   -13278.467   -13278.467    288.59317    288.59317    67908.784    67908.784    360.84559    360.84559 
Loop time of 198.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.034 hours/ns, 5.047 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    | 197.16     | 197.16     | 197.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14988    | 0.14988    | 0.14988    |   0.0 |  0.08
Output  | 0.00017768 | 0.00017768 | 0.00017768 |   0.0 |  0.00
Modify  | 0.71072    | 0.71072    | 0.71072    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320470.0 ave      320470 max      320470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320470
Ave neighs/atom = 80.117500
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 = 292.713598351822, Press = 0.326976828686002
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -13129.29    -13129.29   -13278.467   -13278.467    288.59317    288.59317    67908.784    67908.784    360.84559    360.84559 
   18000   -13125.425   -13125.425   -13276.825   -13276.825    292.89394    292.89394    67973.689    67973.689   -108.56665   -108.56665 
Loop time of 200.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.762 hours/ns, 4.982 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.77     | 199.77     | 199.77     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15052    | 0.15052    | 0.15052    |   0.0 |  0.07
Output  | 0.00022196 | 0.00022196 | 0.00022196 |   0.0 |  0.00
Modify  | 0.72144    | 0.72144    | 0.72144    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320794.0 ave      320794 max      320794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320794
Ave neighs/atom = 80.198500
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 = 292.708846251417, Press = 0.523311577875079
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13125.425   -13125.425   -13276.825   -13276.825    292.89394    292.89394    67973.689    67973.689   -108.56665   -108.56665 
   19000    -13125.16    -13125.16    -13278.14    -13278.14    295.95099    295.95099    67917.634    67917.634    336.41101    336.41101 
Loop time of 197.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.903 hours/ns, 5.059 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    | 196.69     | 196.69     | 196.69     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14848    | 0.14848    | 0.14848    |   0.0 |  0.08
Output  | 0.00017789 | 0.00017789 | 0.00017789 |   0.0 |  0.00
Modify  | 0.70874    | 0.70874    | 0.70874    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320722.0 ave      320722 max      320722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320722
Ave neighs/atom = 80.180500
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 = 292.59016638691, Press = -0.19237233889833
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13125.16    -13125.16    -13278.14    -13278.14    295.95099    295.95099    67917.634    67917.634    336.41101    336.41101 
   20000   -13127.676   -13127.676   -13281.287   -13281.287    297.17144    297.17144    68003.018    68003.018   -802.55993   -802.55993 
Loop time of 195.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.371 hours/ns, 5.109 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    | 194.79     | 194.79     | 194.79     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14869    | 0.14869    | 0.14869    |   0.0 |  0.08
Output  | 0.00018183 | 0.00018183 | 0.00018183 |   0.0 |  0.00
Modify  | 0.69833    | 0.69833    | 0.69833    |   0.0 |  0.36
Other   |            | 0.0993     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320730.0 ave      320730 max      320730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320730
Ave neighs/atom = 80.182500
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 = 292.619897060488, Press = 0.624045983550098
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13127.676   -13127.676   -13281.287   -13281.287    297.17144    297.17144    68003.018    68003.018   -802.55993   -802.55993 
   21000   -13127.524   -13127.524   -13279.646   -13279.646    294.29106    294.29106    67847.293    67847.293     797.3204     797.3204 
Loop time of 197.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.853 hours/ns, 5.064 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    | 196.52     | 196.52     | 196.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14854    | 0.14854    | 0.14854    |   0.0 |  0.08
Output  | 0.0002344  | 0.0002344  | 0.0002344  |   0.0 |  0.00
Modify  | 0.70657    | 0.70657    | 0.70657    |   0.0 |  0.36
Other   |            | 0.09982    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320492.0 ave      320492 max      320492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320492
Ave neighs/atom = 80.123000
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 = 292.622556105274, Press = 0.632214317106595
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13127.524   -13127.524   -13279.646   -13279.646    294.29106    294.29106    67847.293    67847.293     797.3204     797.3204 
   22000   -13124.082   -13124.082   -13276.485   -13276.485    294.83305    294.83305    68054.683    68054.683   -964.80229   -964.80229 
Loop time of 200.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.762 hours/ns, 4.981 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    | 199.78     | 199.78     | 199.78     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.08
Output  | 0.00025384 | 0.00025384 | 0.00025384 |   0.0 |  0.00
Modify  | 0.71558    | 0.71558    | 0.71558    |   0.0 |  0.36
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320850.0 ave      320850 max      320850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320850
Ave neighs/atom = 80.212500
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 = 292.636402665588, Press = -0.486008090463584
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13124.082   -13124.082   -13276.485   -13276.485    294.83305    294.83305    68054.683    68054.683   -964.80229   -964.80229 
   23000    -13126.19    -13126.19   -13278.812   -13278.812    295.25762    295.25762    67850.081    67850.081    882.92679    882.92679 
Loop time of 200.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.786 hours/ns, 4.979 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    | 199.85     | 199.85     | 199.85     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.08
Output  | 0.00018426 | 0.00018426 | 0.00018426 |   0.0 |  0.00
Modify  | 0.72819    | 0.72819    | 0.72819    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320248.0 ave      320248 max      320248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320248
Ave neighs/atom = 80.062000
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 = 292.60779538017, Press = 1.2638545198383
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -13126.19    -13126.19   -13278.812   -13278.812    295.25762    295.25762    67850.081    67850.081    882.92679    882.92679 
   24000   -13124.056   -13124.056    -13274.29    -13274.29    290.63839    290.63839    67984.811    67984.811   -139.16872   -139.16872 
Loop time of 196.408 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.558 hours/ns, 5.091 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    | 195.46     | 195.46     | 195.46     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14781    | 0.14781    | 0.14781    |   0.0 |  0.08
Output  | 0.00017813 | 0.00017813 | 0.00017813 |   0.0 |  0.00
Modify  | 0.69652    | 0.69652    | 0.69652    |   0.0 |  0.35
Other   |            | 0.09879    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320988.0 ave      320988 max      320988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320988
Ave neighs/atom = 80.247000
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 = 292.598632952863, Press = -0.382437003091861
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13124.056   -13124.056    -13274.29    -13274.29    290.63839    290.63839    67984.811    67984.811   -139.16872   -139.16872 
   25000   -13128.355   -13128.355   -13279.245   -13279.245    291.90736    291.90736    67924.029    67924.029     98.26811     98.26811 
Loop time of 199.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.338 hours/ns, 5.020 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    | 198.25     | 198.25     | 198.25     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14972    | 0.14972    | 0.14972    |   0.0 |  0.08
Output  | 0.00017907 | 0.00017907 | 0.00017907 |   0.0 |  0.00
Modify  | 0.71119    | 0.71119    | 0.71119    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320650.0 ave      320650 max      320650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320650
Ave neighs/atom = 80.162500
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 = 292.595613429275, Press = 0.303164760887031
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13128.355   -13128.355   -13279.245   -13279.245    291.90736    291.90736    67924.029    67924.029     98.26811     98.26811 
   26000   -13124.983   -13124.983   -13277.446   -13277.446    294.95097    294.95097    67973.377    67973.377   -257.93517   -257.93517 
Loop time of 198.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.102 hours/ns, 5.041 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    | 197.4      | 197.4      | 197.4      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14934    | 0.14934    | 0.14934    |   0.0 |  0.08
Output  | 0.0001792  | 0.0001792  | 0.0001792  |   0.0 |  0.00
Modify  | 0.71568    | 0.71568    | 0.71568    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320580.0 ave      320580 max      320580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320580
Ave neighs/atom = 80.145000
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 = 292.569937269321, Press = 0.0301323561218302
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13124.983   -13124.983   -13277.446   -13277.446    294.95097    294.95097    67973.377    67973.377   -257.93517   -257.93517 
   27000   -13133.273   -13133.273   -13281.063   -13281.063    285.90887    285.90887    67851.854    67851.854    582.90149    582.90149 
Loop time of 197.419 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.839 hours/ns, 5.065 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    | 196.46     | 196.46     | 196.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14993    | 0.14993    | 0.14993    |   0.0 |  0.08
Output  | 0.00018078 | 0.00018078 | 0.00018078 |   0.0 |  0.00
Modify  | 0.71363    | 0.71363    | 0.71363    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320470.0 ave      320470 max      320470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320470
Ave neighs/atom = 80.117500
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 = 292.574560087587, Press = 0.168128643100319
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13133.273   -13133.273   -13281.063   -13281.063    285.90887    285.90887    67851.854    67851.854    582.90149    582.90149 
   28000    -13125.19    -13125.19   -13277.896   -13277.896    295.41953    295.41953    68057.161    68057.161   -1069.0908   -1069.0908 
Loop time of 196.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.566 hours/ns, 5.091 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    | 195.49     | 195.49     | 195.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14746    | 0.14746    | 0.14746    |   0.0 |  0.08
Output  | 0.00017566 | 0.00017566 | 0.00017566 |   0.0 |  0.00
Modify  | 0.70155    | 0.70155    | 0.70155    |   0.0 |  0.36
Other   |            | 0.09965    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320704.0 ave      320704 max      320704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320704
Ave neighs/atom = 80.176000
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 = 292.534169928668, Press = -0.945975549612719
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -13125.19    -13125.19   -13277.896   -13277.896    295.41953    295.41953    68057.161    68057.161   -1069.0908   -1069.0908 
   29000   -13130.645   -13130.645   -13280.632   -13280.632    290.16081    290.16081    67867.195    67867.195    520.13414    520.13414 
Loop time of 196.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.476 hours/ns, 5.099 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    | 195.16     | 195.16     | 195.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14754    | 0.14754    | 0.14754    |   0.0 |  0.08
Output  | 0.00023606 | 0.00023606 | 0.00023606 |   0.0 |  0.00
Modify  | 0.70355    | 0.70355    | 0.70355    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320262.0 ave      320262 max      320262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320262
Ave neighs/atom = 80.065500
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 = 292.510363505267, Press = 1.83100150902587
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13130.645   -13130.645   -13280.632   -13280.632    290.16081    290.16081    67867.195    67867.195    520.13414    520.13414 
   30000   -13124.642   -13124.642   -13276.676   -13276.676    294.12038    294.12038    67944.957    67944.957    91.830771    91.830771 
Loop time of 194.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.054 hours/ns, 5.139 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    | 193.66     | 193.66     | 193.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14573    | 0.14573    | 0.14573    |   0.0 |  0.07
Output  | 0.00017639 | 0.00017639 | 0.00017639 |   0.0 |  0.00
Modify  | 0.68585    | 0.68585    | 0.68585    |   0.0 |  0.35
Other   |            | 0.1002     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320712.0 ave      320712 max      320712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320712
Ave neighs/atom = 80.178000
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 = 292.530648034503, Press = -1.11365093190756
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13124.642   -13124.642   -13276.676   -13276.676    294.12038    294.12038    67944.957    67944.957    91.830771    91.830771 
   31000    -13128.09    -13128.09   -13277.889   -13277.889    289.79757    289.79757     67984.01     67984.01   -428.97006   -428.97006 
Loop time of 197.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.904 hours/ns, 5.059 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    | 196.7      | 196.7      | 196.7      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14801    | 0.14801    | 0.14801    |   0.0 |  0.07
Output  | 0.00017554 | 0.00017554 | 0.00017554 |   0.0 |  0.00
Modify  | 0.70864    | 0.70864    | 0.70864    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320588.0 ave      320588 max      320588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320588
Ave neighs/atom = 80.147000
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 = 292.541302356107, Press = 0.527662554005477
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -13128.09    -13128.09   -13277.889   -13277.889    289.79757    289.79757     67984.01     67984.01   -428.97006   -428.97006 
   32000   -13122.837   -13122.837   -13276.416   -13276.416    297.10823    297.10823    67917.437    67917.437    390.71894    390.71894 
Loop time of 198.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.130 hours/ns, 5.039 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    | 197.51     | 197.51     | 197.51     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14896    | 0.14896    | 0.14896    |   0.0 |  0.08
Output  | 0.00018017 | 0.00018017 | 0.00018017 |   0.0 |  0.00
Modify  | 0.70726    | 0.70726    | 0.70726    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320364.0 ave      320364 max      320364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320364
Ave neighs/atom = 80.091000
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 = 292.586062558769, Press = 0.253296721339687
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13122.837   -13122.837   -13276.416   -13276.416    297.10823    297.10823    67917.437    67917.437    390.71894    390.71894 
   33000   -13130.483   -13130.483   -13278.994   -13278.994    287.30572    287.30572    67997.726    67997.726   -670.16263   -670.16263 
Loop time of 196.043 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.456 hours/ns, 5.101 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    | 195.09     | 195.09     | 195.09     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14726    | 0.14726    | 0.14726    |   0.0 |  0.08
Output  | 0.00018067 | 0.00018067 | 0.00018067 |   0.0 |  0.00
Modify  | 0.70068    | 0.70068    | 0.70068    |   0.0 |  0.36
Other   |            | 0.09994    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320546.0 ave      320546 max      320546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320546
Ave neighs/atom = 80.136500
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 = 292.567563395645, Press = -0.717283064929037
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13130.483   -13130.483   -13278.994   -13278.994    287.30572    287.30572    67997.726    67997.726   -670.16263   -670.16263 
   34000   -13124.579   -13124.579   -13277.064   -13277.064    294.99276    294.99276    67851.616    67851.616    982.11559    982.11559 
Loop time of 196.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.519 hours/ns, 5.095 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    | 195.33     | 195.33     | 195.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14642    | 0.14642    | 0.14642    |   0.0 |  0.07
Output  | 0.00021915 | 0.00021915 | 0.00021915 |   0.0 |  0.00
Modify  | 0.69179    | 0.69179    | 0.69179    |   0.0 |  0.35
Other   |            | 0.09884    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320266.0 ave      320266 max      320266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320266
Ave neighs/atom = 80.066500
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 = 292.550425045146, Press = 2.02192562901498
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13124.579   -13124.579   -13277.064   -13277.064    294.99276    294.99276    67851.616    67851.616    982.11559    982.11559 
   35000   -13129.325   -13129.325   -13278.496   -13278.496    288.58029    288.58029    67939.975    67939.975   -40.789222   -40.789222 
Loop time of 198.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.195 hours/ns, 5.033 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    | 197.74     | 197.74     | 197.74     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14919    | 0.14919    | 0.14919    |   0.0 |  0.08
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.70977    | 0.70977    | 0.70977    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      321022.0 ave      321022 max      321022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321022
Ave neighs/atom = 80.255500
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 = 292.53412487819, Press = -1.05222298896009
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13129.325   -13129.325   -13278.496   -13278.496    288.58029    288.58029    67939.975    67939.975   -40.789222   -40.789222 
   36000   -13122.483   -13122.483   -13275.137   -13275.137    295.31917    295.31917    67974.826    67974.826   -14.142531   -14.142531 
Loop time of 198.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.091 hours/ns, 5.042 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    | 197.37     | 197.37     | 197.37     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14799    | 0.14799    | 0.14799    |   0.0 |  0.07
Output  | 0.00023272 | 0.00023272 | 0.00023272 |   0.0 |  0.00
Modify  | 0.7121     | 0.7121     | 0.7121     |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320570.0 ave      320570 max      320570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320570
Ave neighs/atom = 80.142500
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 = 292.571373285661, Press = 1.04426730874072
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13122.483   -13122.483   -13275.137   -13275.137    295.31917    295.31917    67974.826    67974.826   -14.142531   -14.142531 
   37000   -13127.898   -13127.898   -13280.284   -13280.284    294.80016    294.80016    67900.229    67900.229    319.03519    319.03519 
Loop time of 195.151 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.209 hours/ns, 5.124 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    | 194.21     | 194.21     | 194.21     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14599    | 0.14599    | 0.14599    |   0.0 |  0.07
Output  | 0.00023273 | 0.00023273 | 0.00023273 |   0.0 |  0.00
Modify  | 0.69035    | 0.69035    | 0.69035    |   0.0 |  0.35
Other   |            | 0.09966    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320706.0 ave      320706 max      320706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320706
Ave neighs/atom = 80.176500
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 = 292.596959603099, Press = -0.223833847540623
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13127.898   -13127.898   -13280.284   -13280.284    294.80016    294.80016    67900.229    67900.229    319.03519    319.03519 
   38000   -13120.763   -13120.763   -13272.356   -13272.356    293.26534    293.26534    68010.664    68010.664    -98.46052    -98.46052 
Loop time of 198.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.119 hours/ns, 5.040 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.47     | 197.47     | 197.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15067    | 0.15067    | 0.15067    |   0.0 |  0.08
Output  | 0.00017687 | 0.00017687 | 0.00017687 |   0.0 |  0.00
Modify  | 0.70724    | 0.70724    | 0.70724    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320610.0 ave      320610 max      320610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320610
Ave neighs/atom = 80.152500
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 = 292.624436881918, Press = 0.415027693020483
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13120.763   -13120.763   -13272.356   -13272.356    293.26534    293.26534    68010.664    68010.664    -98.46052    -98.46052 
   39000   -13127.196   -13127.196   -13276.771   -13276.771    289.36352    289.36352    67913.946    67913.946    386.54257    386.54257 
Loop time of 195.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.419 hours/ns, 5.104 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    | 194.96     | 194.96     | 194.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.08
Output  | 0.00017461 | 0.00017461 | 0.00017461 |   0.0 |  0.00
Modify  | 0.69697    | 0.69697    | 0.69697    |   0.0 |  0.36
Other   |            | 0.09932    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320544.0 ave      320544 max      320544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320544
Ave neighs/atom = 80.136000
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 = 292.703738688477, Press = -0.137655579685524
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13127.196   -13127.196   -13276.771   -13276.771    289.36352    289.36352    67913.946    67913.946    386.54257    386.54257 
   40000   -13123.774   -13123.774   -13275.097   -13275.097    292.74357    292.74357    68020.319    68020.319   -471.13362   -471.13362 
Loop time of 199.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.314 hours/ns, 5.022 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    | 198.17     | 198.17     | 198.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14977    | 0.14977    | 0.14977    |   0.0 |  0.08
Output  | 0.00017633 | 0.00017633 | 0.00017633 |   0.0 |  0.00
Modify  | 0.71046    | 0.71046    | 0.71046    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320862.0 ave      320862 max      320862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320862
Ave neighs/atom = 80.215500
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 = 292.738496496232, Press = 0.178339651547995
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13123.774   -13123.774   -13275.097   -13275.097    292.74357    292.74357    68020.319    68020.319   -471.13362   -471.13362 
   41000   -13128.715   -13128.715   -13280.955   -13280.955    294.51759    294.51759    67811.562    67811.562    1063.3719    1063.3719 
Loop time of 196.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.518 hours/ns, 5.095 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    | 195.33     | 195.33     | 195.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14647    | 0.14647    | 0.14647    |   0.0 |  0.07
Output  | 0.00018124 | 0.00018124 | 0.00018124 |   0.0 |  0.00
Modify  | 0.69424    | 0.69424    | 0.69424    |   0.0 |  0.35
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320498.0 ave      320498 max      320498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320498
Ave neighs/atom = 80.124500
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 = 292.765824828498, Press = 0.576548341529852
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13128.715   -13128.715   -13280.955   -13280.955    294.51759    294.51759    67811.562    67811.562    1063.3719    1063.3719 
   42000   -13123.058   -13123.058    -13274.54    -13274.54    293.05252    293.05252    68062.106    68062.106    -833.9037    -833.9037 
Loop time of 193.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.884 hours/ns, 5.155 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    | 193.05     | 193.05     | 193.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14566    | 0.14566    | 0.14566    |   0.0 |  0.08
Output  | 0.00023589 | 0.00023589 | 0.00023589 |   0.0 |  0.00
Modify  | 0.68413    | 0.68413    | 0.68413    |   0.0 |  0.35
Other   |            | 0.09877    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      321020.0 ave      321020 max      321020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321020
Ave neighs/atom = 80.255000
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 = 292.78210523705, Press = -0.838764506659607
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13123.058   -13123.058    -13274.54    -13274.54    293.05252    293.05252    68062.106    68062.106    -833.9037    -833.9037 
   43000   -13126.491   -13126.491   -13278.033   -13278.033    293.16847    293.16847    67920.529    67920.529    255.22753    255.22753 
Loop time of 195.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.363 hours/ns, 5.110 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    | 194.76     | 194.76     | 194.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14892    | 0.14892    | 0.14892    |   0.0 |  0.08
Output  | 0.00017636 | 0.00017636 | 0.00017636 |   0.0 |  0.00
Modify  | 0.70026    | 0.70026    | 0.70026    |   0.0 |  0.36
Other   |            | 0.09993    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320370.0 ave      320370 max      320370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320370
Ave neighs/atom = 80.092500
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 = 292.755312293614, Press = 0.483783459830724
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13126.491   -13126.491   -13278.033   -13278.033    293.16847    293.16847    67920.529    67920.529    255.22753    255.22753 
   44000   -13128.669   -13128.669   -13277.366   -13277.366    287.66404    287.66404    67946.944    67946.944   -31.994272   -31.994272 
Loop time of 197.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.758 hours/ns, 5.073 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    | 196.18     | 196.18     | 196.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14847    | 0.14847    | 0.14847    |   0.0 |  0.08
Output  | 0.00017673 | 0.00017673 | 0.00017673 |   0.0 |  0.00
Modify  | 0.70206    | 0.70206    | 0.70206    |   0.0 |  0.36
Other   |            | 0.09979    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320590.0 ave      320590 max      320590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320590
Ave neighs/atom = 80.147500
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 = 292.759950139222, Press = -0.196133054072117
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13128.669   -13128.669   -13277.366   -13277.366    287.66404    287.66404    67946.944    67946.944   -31.994272   -31.994272 
   45000   -13123.856   -13123.856   -13277.861   -13277.861    297.93417    297.93417    67955.658    67955.658   -57.807846   -57.807846 
Loop time of 199.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.436 hours/ns, 5.011 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    | 198.61     | 198.61     | 198.61     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15007    | 0.15007    | 0.15007    |   0.0 |  0.08
Output  | 0.00018121 | 0.00018121 | 0.00018121 |   0.0 |  0.00
Modify  | 0.71238    | 0.71238    | 0.71238    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320612.0 ave      320612 max      320612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320612
Ave neighs/atom = 80.153000
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 = 292.765180923384, Press = -0.289699478355367
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13123.856   -13123.856   -13277.861   -13277.861    297.93417    297.93417    67955.658    67955.658   -57.807846   -57.807846 
   46000   -13126.927   -13126.927   -13277.714   -13277.714    291.70802    291.70802    67968.504    67968.504   -254.25193   -254.25193 
Loop time of 198.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.135 hours/ns, 5.038 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    | 197.53     | 197.53     | 197.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.08
Output  | 0.0002336  | 0.0002336  | 0.0002336  |   0.0 |  0.00
Modify  | 0.71032    | 0.71032    | 0.71032    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320600.0 ave      320600 max      320600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320600
Ave neighs/atom = 80.150000
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 = 292.798327104928, Press = 0.161847819752229
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13126.927   -13126.927   -13277.714   -13277.714    291.70802    291.70802    67968.504    67968.504   -254.25193   -254.25193 
   47000   -13125.084   -13125.084   -13278.878   -13278.878    297.52544    297.52544      67941.9      67941.9   -15.747372   -15.747372 
Loop time of 199.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.292 hours/ns, 5.024 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    | 198.08     | 198.08     | 198.08     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15       | 0.15       | 0.15       |   0.0 |  0.08
Output  | 0.00022216 | 0.00022216 | 0.00022216 |   0.0 |  0.00
Modify  | 0.71343    | 0.71343    | 0.71343    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320706.0 ave      320706 max      320706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320706
Ave neighs/atom = 80.176500
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 = 292.824359467235, Press = 0.0914396135391236
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13125.084   -13125.084   -13278.878   -13278.878    297.52544    297.52544      67941.9      67941.9   -15.747372   -15.747372 
   48000   -13124.653   -13124.653     -13277.9     -13277.9    296.46768    296.46768    67983.169    67983.169   -331.49686   -331.49686 
Loop time of 199.276 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.355 hours/ns, 5.018 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    | 198.32     | 198.32     | 198.32     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.08
Output  | 0.00017544 | 0.00017544 | 0.00017544 |   0.0 |  0.00
Modify  | 0.7085     | 0.7085     | 0.7085     |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320602.0 ave      320602 max      320602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320602
Ave neighs/atom = 80.150500
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 = 292.828421907038, Press = -0.264837292003107
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13124.653   -13124.653     -13277.9     -13277.9    296.46768    296.46768    67983.169    67983.169   -331.49686   -331.49686 
   49000   -13124.881   -13124.881   -13276.583   -13276.583     293.4779     293.4779    67949.855    67949.855    85.324055    85.324055 
Loop time of 198.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.023 hours/ns, 5.048 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    | 197.12     | 197.12     | 197.12     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15139    | 0.15139    | 0.15139    |   0.0 |  0.08
Output  | 0.00022579 | 0.00022579 | 0.00022579 |   0.0 |  0.00
Modify  | 0.70873    | 0.70873    | 0.70873    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320524.0 ave      320524 max      320524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320524
Ave neighs/atom = 80.131000
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 = 292.88839755165, Press = 0.0339150560708308
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13124.881   -13124.881   -13276.583   -13276.583     293.4779     293.4779    67949.855    67949.855    85.324055    85.324055 
   50000    -13123.13    -13123.13   -13274.656   -13274.656    293.13726    293.13726    67955.697    67955.697    256.55586    256.55586 
Loop time of 195.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.286 hours/ns, 5.117 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    | 194.48     | 194.48     | 194.48     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14779    | 0.14779    | 0.14779    |   0.0 |  0.08
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.69618    | 0.69618    | 0.69618    |   0.0 |  0.36
Other   |            | 0.09939    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320586.0 ave      320586 max      320586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320586
Ave neighs/atom = 80.146500
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 = 292.896835652478, Press = -0.271328587992864
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -13123.13    -13123.13   -13274.656   -13274.656    293.13726    293.13726    67955.697    67955.697    256.55586    256.55586 
   51000   -13127.092   -13127.092   -13276.464   -13276.464    288.97091    288.97091    67989.736    67989.736   -356.46495   -356.46495 
Loop time of 192.061 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.350 hours/ns, 5.207 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    | 191.14     | 191.14     | 191.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14535    | 0.14535    | 0.14535    |   0.0 |  0.08
Output  | 0.00017668 | 0.00017668 | 0.00017668 |   0.0 |  0.00
Modify  | 0.67732    | 0.67732    | 0.67732    |   0.0 |  0.35
Other   |            | 0.09815    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320558.0 ave      320558 max      320558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320558
Ave neighs/atom = 80.139500
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 = 292.938461118125, Press = -0.021467747551632
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13127.092   -13127.092   -13276.464   -13276.464    288.97091    288.97091    67989.736    67989.736   -356.46495   -356.46495 
   52000   -13122.221   -13122.221   -13275.668   -13275.668    296.85293    296.85293    67902.325    67902.325    688.90956    688.90956 
Loop time of 196.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.585 hours/ns, 5.089 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    | 195.55     | 195.55     | 195.55     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14788    | 0.14788    | 0.14788    |   0.0 |  0.08
Output  | 0.00019058 | 0.00019058 | 0.00019058 |   0.0 |  0.00
Modify  | 0.70412    | 0.70412    | 0.70412    |   0.0 |  0.36
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      320526.0 ave      320526 max      320526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320526
Ave neighs/atom = 80.131500
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
67950.1202163421

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0