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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.613315641880036*${_u_distance}
variable latticeconst_converted equal 3.613315641880036*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564188004
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
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 (36.133156 36.133156 36.133156)
  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 (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuCo__MO_849011491644_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6294254851 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_849011491644_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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -14018.806   -14018.806       -14160       -14160       273.15       273.15    47175.629    47175.629    3196.8241    3196.8241 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2819   -1401.2819 
Loop time of 166.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.518 ns/day, 46.325 hours/ns, 5.996 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    | 165.83     | 165.83     | 165.83     |   0.0 | 99.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15296    | 0.15296    | 0.15296    |   0.0 |  0.09
Output  | 0.00022521 | 0.00022521 | 0.00022521 |   0.0 |  0.00
Modify  | 0.68619    | 0.68619    | 0.68619    |   0.0 |  0.41
Other   |            | 0.09908    |            |       |  0.06

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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54.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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2819   -1401.2819 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069     -480.351     -480.351 
Loop time of 183.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.957 hours/ns, 5.451 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    | 182.52     | 182.52     | 182.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15175    | 0.15175    | 0.15175    |   0.0 |  0.08
Output  | 0.00031559 | 0.00031559 | 0.00031559 |   0.0 |  0.00
Modify  | 0.67716    | 0.67716    | 0.67716    |   0.0 |  0.37
Other   |            | 0.09768    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248176.0 ave      248176 max      248176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248176
Ave neighs/atom = 62.044000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069     -480.351     -480.351 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83354   -639.83354 
Loop time of 185.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.391 hours/ns, 5.405 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    | 184.07     | 184.07     | 184.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15148    | 0.15148    | 0.15148    |   0.0 |  0.08
Output  | 0.00021173 | 0.00021173 | 0.00021173 |   0.0 |  0.00
Modify  | 0.68537    | 0.68537    | 0.68537    |   0.0 |  0.37
Other   |            | 0.09929    |            |       |  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:      248508.0 ave      248508 max      248508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248508
Ave neighs/atom = 62.127000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83354   -639.83354 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44909   -856.44909 
Loop time of 185.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.465 ns/day, 51.591 hours/ns, 5.384 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    | 184.78     | 184.78     | 184.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.08
Output  | 0.00026533 | 0.00026533 | 0.00026533 |   0.0 |  0.00
Modify  | 0.69006    | 0.69006    | 0.69006    |   0.0 |  0.37
Other   |            | 0.09912    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5838.00 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248268.0 ave      248268 max      248268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248268
Ave neighs/atom = 62.067000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44909   -856.44909 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31182    265.31182    47860.951    47860.951    513.55703    513.55703 
Loop time of 188.233 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.287 hours/ns, 5.313 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    | 187.27     | 187.27     | 187.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1535     | 0.1535     | 0.1535     |   0.0 |  0.08
Output  | 0.00017625 | 0.00017625 | 0.00017625 |   0.0 |  0.00
Modify  | 0.70579    | 0.70579    | 0.70579    |   0.0 |  0.37
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:        5837.00 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248492.0 ave      248492 max      248492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248492
Ave neighs/atom = 62.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 = 274.452431478479, Press = 727.423106822539
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31182    265.31182    47860.951    47860.951    513.55703    513.55703 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358    1491.2025    1491.2025 
Loop time of 189.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.550 hours/ns, 5.286 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    | 188.19     | 188.19     | 188.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15394    | 0.15394    | 0.15394    |   0.0 |  0.08
Output  | 0.00028288 | 0.00028288 | 0.00028288 |   0.0 |  0.00
Modify  | 0.72927    | 0.72927    | 0.72927    |   0.0 |  0.39
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:      248856.0 ave      248856 max      248856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248856
Ave neighs/atom = 62.214000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.610071935883, Press = 17.7903428562303
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358    1491.2025    1491.2025 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1863   -1036.1863 
Loop time of 187.384 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.051 hours/ns, 5.337 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    | 186.41     | 186.41     | 186.41     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15306    | 0.15306    | 0.15306    |   0.0 |  0.08
Output  | 0.00018078 | 0.00018078 | 0.00018078 |   0.0 |  0.00
Modify  | 0.71895    | 0.71895    | 0.71895    |   0.0 |  0.38
Other   |            | 0.09945    |            |       |  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:      249112.0 ave      249112 max      249112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249112
Ave neighs/atom = 62.278000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.012114543748, Press = -4.48329208694195
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1863   -1036.1863 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154    -711.7199    -711.7199 
Loop time of 183.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.472 ns/day, 50.891 hours/ns, 5.458 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    | 182.26     | 182.26     | 182.26     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15128    | 0.15128    | 0.15128    |   0.0 |  0.08
Output  | 0.00023624 | 0.00023624 | 0.00023624 |   0.0 |  0.00
Modify  | 0.69846    | 0.69846    | 0.69846    |   0.0 |  0.38
Other   |            | 0.09809    |            |       |  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:      248124.0 ave      248124 max      248124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248124
Ave neighs/atom = 62.031000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.088072741246, Press = 19.9536928737478
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154    -711.7199    -711.7199 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41892    273.41892     47847.43     47847.43    1351.3957    1351.3957 
Loop time of 184.76 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.322 hours/ns, 5.412 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    | 183.8      | 183.8      | 183.8      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15179    | 0.15179    | 0.15179    |   0.0 |  0.08
Output  | 0.00021771 | 0.00021771 | 0.00021771 |   0.0 |  0.00
Modify  | 0.70771    | 0.70771    | 0.70771    |   0.0 |  0.38
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:      248308.0 ave      248308 max      248308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248308
Ave neighs/atom = 62.077000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.383464255596, Press = 12.2281028841921
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41892    273.41892     47847.43     47847.43    1351.3957    1351.3957 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46095    271.46095    47872.004    47872.004    394.42874    394.42874 
Loop time of 186.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.464 ns/day, 51.714 hours/ns, 5.371 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    | 185.2      | 185.2      | 185.2      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15186    | 0.15186    | 0.15186    |   0.0 |  0.08
Output  | 0.00017526 | 0.00017526 | 0.00017526 |   0.0 |  0.00
Modify  | 0.71505    | 0.71505    | 0.71505    |   0.0 |  0.38
Other   |            | 0.09985    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      249208.0 ave      249208 max      249208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249208
Ave neighs/atom = 62.302000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.298218927204, Press = 4.11257335760912
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46095    271.46095    47872.004    47872.004    394.42874    394.42874 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.70186   -896.70186 
Loop time of 184.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.229 hours/ns, 5.422 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    | 183.47     | 183.47     | 183.47     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.08
Output  | 0.00017887 | 0.00017887 | 0.00017887 |   0.0 |  0.00
Modify  | 0.70598    | 0.70598    | 0.70598    |   0.0 |  0.38
Other   |            | 0.09881    |            |       |  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:      248828.0 ave      248828 max      248828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248828
Ave neighs/atom = 62.207000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.181711124339, Press = 2.01453992131698
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.70186   -896.70186 
   12000   -13879.029   -13879.029   -14019.863   -14019.863     272.4539     272.4539    47887.829    47887.829   -429.56158   -429.56158 
Loop time of 185.636 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.465 ns/day, 51.565 hours/ns, 5.387 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    | 184.67     | 184.67     | 184.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.08
Output  | 0.00017478 | 0.00017478 | 0.00017478 |   0.0 |  0.00
Modify  | 0.71355    | 0.71355    | 0.71355    |   0.0 |  0.38
Other   |            | 0.09973    |            |       |  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:      248196.0 ave      248196 max      248196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248196
Ave neighs/atom = 62.049000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.921835659245, Press = 11.4619190621826
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13879.029   -13879.029   -14019.863   -14019.863     272.4539     272.4539    47887.829    47887.829   -429.56158   -429.56158 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74981    273.74981    47798.836    47798.836    2059.7491    2059.7491 
Loop time of 185.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.420 hours/ns, 5.402 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    | 184.15     | 184.15     | 184.15     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15056    | 0.15056    | 0.15056    |   0.0 |  0.08
Output  | 0.0001769  | 0.0001769  | 0.0001769  |   0.0 |  0.00
Modify  | 0.71013    | 0.71013    | 0.71013    |   0.0 |  0.38
Other   |            | 0.09925    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248038.0 ave      248038 max      248038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248038
Ave neighs/atom = 62.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.939815223773, Press = 2.55583020664328
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74981    273.74981    47798.836    47798.836    2059.7491    2059.7491 
   14000    -13872.14    -13872.14   -14013.705   -14013.705    273.86852    273.86852    47913.931    47913.931   -537.42377   -537.42377 
Loop time of 185.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.465 ns/day, 51.632 hours/ns, 5.380 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    | 184.91     | 184.91     | 184.91     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15188    | 0.15188    | 0.15188    |   0.0 |  0.08
Output  | 0.00018108 | 0.00018108 | 0.00018108 |   0.0 |  0.00
Modify  | 0.71574    | 0.71574    | 0.71574    |   0.0 |  0.39
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:      249676.0 ave      249676 max      249676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249676
Ave neighs/atom = 62.419000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.053838875802, Press = 0.995201004766443
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -13872.14    -13872.14   -14013.705   -14013.705    273.86852    273.86852    47913.931    47913.931   -537.42377   -537.42377 
   15000    -13879.09    -13879.09   -14019.725   -14019.725    272.06687    272.06687    47872.855    47872.855   -93.022823   -93.022823 
Loop time of 184.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.115 hours/ns, 5.434 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    | 183.05     | 183.05     | 183.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15243    | 0.15243    | 0.15243    |   0.0 |  0.08
Output  | 0.00045397 | 0.00045397 | 0.00045397 |   0.0 |  0.00
Modify  | 0.70686    | 0.70686    | 0.70686    |   0.0 |  0.38
Other   |            | 0.0989     |            |       |  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:      248060.0 ave      248060 max      248060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248060
Ave neighs/atom = 62.015000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.187708733899, Press = 3.89239997005888
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -13879.09    -13879.09   -14019.725   -14019.725    272.06687    272.06687    47872.855    47872.855   -93.022823   -93.022823 
   16000   -13882.526   -13882.526   -14022.502   -14022.502     270.7925     270.7925    47843.464    47843.464    497.36072    497.36072 
Loop time of 186.213 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.464 ns/day, 51.726 hours/ns, 5.370 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    | 185.24     | 185.24     | 185.24     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1517     | 0.1517     | 0.1517     |   0.0 |  0.08
Output  | 0.00017455 | 0.00017455 | 0.00017455 |   0.0 |  0.00
Modify  | 0.71726    | 0.71726    | 0.71726    |   0.0 |  0.39
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:      248612.0 ave      248612 max      248612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248612
Ave neighs/atom = 62.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 = 273.159248440099, Press = 3.82004052417522
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13882.526   -13882.526   -14022.502   -14022.502     270.7925     270.7925    47843.464    47843.464    497.36072    497.36072 
   17000    -13874.87    -13874.87    -14016.19    -14016.19     273.3917     273.3917    47860.675    47860.675    750.53666    750.53666 
Loop time of 184.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.191 hours/ns, 5.426 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    | 183.33     | 183.33     | 183.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15201    | 0.15201    | 0.15201    |   0.0 |  0.08
Output  | 0.0001781  | 0.0001781  | 0.0001781  |   0.0 |  0.00
Modify  | 0.70926    | 0.70926    | 0.70926    |   0.0 |  0.38
Other   |            | 0.09838    |            |       |  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:      248902.0 ave      248902 max      248902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248902
Ave neighs/atom = 62.225500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.066182078193, Press = 1.5177583037603
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -13874.87    -13874.87    -14016.19    -14016.19     273.3917     273.3917    47860.675    47860.675    750.53666    750.53666 
   18000    -13878.83    -13878.83   -14019.509   -14019.509    272.15405    272.15405    47903.813    47903.813   -976.75966   -976.75966 
Loop time of 184.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.379 hours/ns, 5.406 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    | 184        | 184        | 184        |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15155    | 0.15155    | 0.15155    |   0.0 |  0.08
Output  | 0.00017906 | 0.00017906 | 0.00017906 |   0.0 |  0.00
Modify  | 0.70874    | 0.70874    | 0.70874    |   0.0 |  0.38
Other   |            | 0.09865    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248746.0 ave      248746 max      248746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248746
Ave neighs/atom = 62.186500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.204633818053, Press = 0.309423616013259
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -13878.83    -13878.83   -14019.509   -14019.509    272.15405    272.15405    47903.813    47903.813   -976.75966   -976.75966 
   19000   -13872.794   -13872.794    -14012.99    -14012.99    271.21957    271.21957    47912.299    47912.299   -464.54442   -464.54442 
Loop time of 184.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.312 hours/ns, 5.413 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    | 183.76     | 183.76     | 183.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15257    | 0.15257    | 0.15257    |   0.0 |  0.08
Output  | 0.00017632 | 0.00017632 | 0.00017632 |   0.0 |  0.00
Modify  | 0.71555    | 0.71555    | 0.71555    |   0.0 |  0.39
Other   |            | 0.09866    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248512.0 ave      248512 max      248512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248512
Ave neighs/atom = 62.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.268309217064, Press = 4.24503749704989
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13872.794   -13872.794    -14012.99    -14012.99    271.21957    271.21957    47912.299    47912.299   -464.54442   -464.54442 
   20000   -13879.937   -13879.937   -14021.649   -14021.649    274.15093    274.15093    47800.888    47800.888    1837.4541    1837.4541 
Loop time of 184.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.179 hours/ns, 5.428 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    | 183.29     | 183.29     | 183.29     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15012    | 0.15012    | 0.15012    |   0.0 |  0.08
Output  | 0.00017945 | 0.00017945 | 0.00017945 |   0.0 |  0.00
Modify  | 0.70318    | 0.70318    | 0.70318    |   0.0 |  0.38
Other   |            | 0.0986     |            |       |  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:      248580.0 ave      248580 max      248580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248580
Ave neighs/atom = 62.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 = 273.334900421573, Press = 2.315552864916
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13879.937   -13879.937   -14021.649   -14021.649    274.15093    274.15093    47800.888    47800.888    1837.4541    1837.4541 
   21000    -13877.16    -13877.16   -14019.362   -14019.362    275.10031    275.10031    47889.635    47889.635   -355.36658   -355.36658 
Loop time of 183.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.015 hours/ns, 5.445 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    | 182.71     | 182.71     | 182.71     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15017    | 0.15017    | 0.15017    |   0.0 |  0.08
Output  | 0.0002262  | 0.0002262  | 0.0002262  |   0.0 |  0.00
Modify  | 0.69744    | 0.69744    | 0.69744    |   0.0 |  0.38
Other   |            | 0.0985     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      249438.0 ave      249438 max      249438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249438
Ave neighs/atom = 62.359500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.304854527738, Press = -1.71897624903228
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -13877.16    -13877.16   -14019.362   -14019.362    275.10031    275.10031    47889.635    47889.635   -355.36658   -355.36658 
   22000   -13877.694   -13877.694   -14018.377   -14018.377    272.16037    272.16037    47932.084    47932.084   -1629.2474   -1629.2474 
Loop time of 186.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.798 hours/ns, 5.363 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.5      | 185.5      | 185.5      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.08
Output  | 0.00017976 | 0.00017976 | 0.00017976 |   0.0 |  0.00
Modify  | 0.71932    | 0.71932    | 0.71932    |   0.0 |  0.39
Other   |            | 0.09958    |            |       |  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:      248048.0 ave      248048 max      248048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248048
Ave neighs/atom = 62.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.288539745263, Press = 2.94098063584443
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13877.694   -13877.694   -14018.377   -14018.377    272.16037    272.16037    47932.084    47932.084   -1629.2474   -1629.2474 
   23000   -13880.136   -13880.136   -14018.128   -14018.128    266.95486    266.95486    47849.404    47849.404    809.18278    809.18278 
Loop time of 184.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.287 hours/ns, 5.416 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    | 183.67     | 183.67     | 183.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15229    | 0.15229    | 0.15229    |   0.0 |  0.08
Output  | 0.00017737 | 0.00017737 | 0.00017737 |   0.0 |  0.00
Modify  | 0.71093    | 0.71093    | 0.71093    |   0.0 |  0.39
Other   |            | 0.09975    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5837.00 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      247406.0 ave      247406 max      247406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247406
Ave neighs/atom = 61.851500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.244508779996, Press = 2.87839596492798
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13880.136   -13880.136   -14018.128   -14018.128    266.95486    266.95486    47849.404    47849.404    809.18278    809.18278 
   24000   -13879.281   -13879.281   -14020.134   -14020.134    272.48833    272.48833    47858.367    47858.367    385.79167    385.79167 
Loop time of 184.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.470 ns/day, 51.118 hours/ns, 5.434 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    | 183.07     | 183.07     | 183.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15167    | 0.15167    | 0.15167    |   0.0 |  0.08
Output  | 0.00017986 | 0.00017986 | 0.00017986 |   0.0 |  0.00
Modify  | 0.70459    | 0.70459    | 0.70459    |   0.0 |  0.38
Other   |            | 0.0996     |            |       |  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:      248918.0 ave      248918 max      248918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248918
Ave neighs/atom = 62.229500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.209696377706, Press = 0.838068667097971
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13879.281   -13879.281   -14020.134   -14020.134    272.48833    272.48833    47858.367    47858.367    385.79167    385.79167 
   25000   -13876.001   -13876.001   -14015.642   -14015.642    270.14494    270.14494    47909.711    47909.711    -607.6905    -607.6905 
Loop time of 184.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.188 hours/ns, 5.427 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    | 183.32     | 183.32     | 183.32     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.08
Output  | 0.00034713 | 0.00034713 | 0.00034713 |   0.0 |  0.00
Modify  | 0.70567    | 0.70567    | 0.70567    |   0.0 |  0.38
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:      248584.0 ave      248584 max      248584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248584
Ave neighs/atom = 62.146000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.116699540512, Press = 0.90436886976952
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13876.001   -13876.001   -14015.642   -14015.642    270.14494    270.14494    47909.711    47909.711    -607.6905    -607.6905 
   26000   -13879.969   -13879.969   -14018.461   -14018.461    267.92208    267.92208    47885.694    47885.694   -212.38476   -212.38476 
Loop time of 184.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.241 hours/ns, 5.421 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    | 183.51     | 183.51     | 183.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15102    | 0.15102    | 0.15102    |   0.0 |  0.08
Output  | 0.00018055 | 0.00018055 | 0.00018055 |   0.0 |  0.00
Modify  | 0.70847    | 0.70847    | 0.70847    |   0.0 |  0.38
Other   |            | 0.09964    |            |       |  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:      248142.0 ave      248142 max      248142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248142
Ave neighs/atom = 62.035500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.062396976364, Press = 4.08956355794209
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13879.969   -13879.969   -14018.461   -14018.461    267.92208    267.92208    47885.694    47885.694   -212.38476   -212.38476 
   27000   -13875.005   -13875.005    -14015.53    -14015.53    271.85539    271.85539    47785.665    47785.665    2974.1044    2974.1044 
Loop time of 185.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.413 hours/ns, 5.403 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    | 184.12     | 184.12     | 184.12     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15222    | 0.15222    | 0.15222    |   0.0 |  0.08
Output  | 0.00018    | 0.00018    | 0.00018    |   0.0 |  0.00
Modify  | 0.71207    | 0.71207    | 0.71207    |   0.0 |  0.38
Other   |            | 0.09863    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248196.0 ave      248196 max      248196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248196
Ave neighs/atom = 62.049000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017311539871, Press = 1.76686102407661
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13875.005   -13875.005    -14015.53    -14015.53    271.85539    271.85539    47785.665    47785.665    2974.1044    2974.1044 
   28000   -13881.033   -13881.033   -14019.675   -14019.675    268.21213    268.21213    47885.826    47885.826   -342.51349   -342.51349 
Loop time of 186.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.464 ns/day, 51.718 hours/ns, 5.371 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    | 185.22     | 185.22     | 185.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15129    | 0.15129    | 0.15129    |   0.0 |  0.08
Output  | 0.00018187 | 0.00018187 | 0.00018187 |   0.0 |  0.00
Modify  | 0.71397    | 0.71397    | 0.71397    |   0.0 |  0.38
Other   |            | 0.09928    |            |       |  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:      249834.0 ave      249834 max      249834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249834
Ave neighs/atom = 62.458500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.976843398798, Press = -0.529147489806743
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13881.033   -13881.033   -14019.675   -14019.675    268.21213    268.21213    47885.826    47885.826   -342.51349   -342.51349 
   29000   -13876.623   -13876.623   -14017.531   -14017.531    272.59654    272.59654    47906.323    47906.323   -777.29582   -777.29582 
Loop time of 184.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.469 ns/day, 51.146 hours/ns, 5.431 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    | 183.16     | 183.16     | 183.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15081    | 0.15081    | 0.15081    |   0.0 |  0.08
Output  | 0.00022572 | 0.00022572 | 0.00022572 |   0.0 |  0.00
Modify  | 0.7107     | 0.7107     | 0.7107     |   0.0 |  0.39
Other   |            | 0.09945    |            |       |  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:      248214.0 ave      248214 max      248214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248214
Ave neighs/atom = 62.053500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.959147269083, Press = 2.15083561668761
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13876.623   -13876.623   -14017.531   -14017.531    272.59654    272.59654    47906.323    47906.323   -777.29582   -777.29582 
   30000   -13880.105   -13880.105   -14020.329   -14020.329    271.27278    271.27278    47831.782    47831.782    1066.5912    1066.5912 
Loop time of 182.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.473 ns/day, 50.719 hours/ns, 5.477 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    | 181.64     | 181.64     | 181.64     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1507     | 0.1507     | 0.1507     |   0.0 |  0.08
Output  | 0.00018091 | 0.00018091 | 0.00018091 |   0.0 |  0.00
Modify  | 0.70171    | 0.70171    | 0.70171    |   0.0 |  0.38
Other   |            | 0.09888    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      247848.0 ave      247848 max      247848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247848
Ave neighs/atom = 61.962000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.909595762187, Press = 1.76165533735218
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13880.105   -13880.105   -14020.329   -14020.329    271.27278    271.27278    47831.782    47831.782    1066.5912    1066.5912 
   31000   -13875.378   -13875.378   -14015.374   -14015.374     270.8321     270.8321    47860.639    47860.639    850.85044    850.85044 
Loop time of 181.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.310 hours/ns, 5.521 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    | 180.18     | 180.18     | 180.18     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14832    | 0.14832    | 0.14832    |   0.0 |  0.08
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.68945    | 0.68945    | 0.68945    |   0.0 |  0.38
Other   |            | 0.09848    |            |       |  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:      249024.0 ave      249024 max      249024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249024
Ave neighs/atom = 62.256000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.884417278094, Press = 0.73637379601195
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13875.378   -13875.378   -14015.374   -14015.374     270.8321     270.8321    47860.639    47860.639    850.85044    850.85044 
   32000    -13880.73    -13880.73   -14017.668   -14017.668    264.91435    264.91435    47914.423    47914.423   -1115.4947   -1115.4947 
Loop time of 180.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.236 hours/ns, 5.529 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    | 179.92     | 179.92     | 179.92     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14891    | 0.14891    | 0.14891    |   0.0 |  0.08
Output  | 0.00017957 | 0.00017957 | 0.00017957 |   0.0 |  0.00
Modify  | 0.68777    | 0.68777    | 0.68777    |   0.0 |  0.38
Other   |            | 0.09819    |            |       |  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:      248826.0 ave      248826 max      248826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248826
Ave neighs/atom = 62.206500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.865114782254, Press = -0.237778446365065
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -13880.73    -13880.73   -14017.668   -14017.668    264.91435    264.91435    47914.423    47914.423   -1115.4947   -1115.4947 
   33000   -13875.624   -13875.624   -14017.485   -14017.485    274.43969    274.43969    47914.803    47914.803   -895.21808   -895.21808 
Loop time of 180.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.207 hours/ns, 5.533 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    | 179.81     | 179.81     | 179.81     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14873    | 0.14873    | 0.14873    |   0.0 |  0.08
Output  | 0.00017604 | 0.00017604 | 0.00017604 |   0.0 |  0.00
Modify  | 0.6905     | 0.6905     | 0.6905     |   0.0 |  0.38
Other   |            | 0.0984     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5834.00 ave        5834 max        5834 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      247766.0 ave      247766 max      247766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247766
Ave neighs/atom = 61.941500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.88357700807, Press = 2.8280921972173
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13875.624   -13875.624   -14017.485   -14017.485    274.43969    274.43969    47914.803    47914.803   -895.21808   -895.21808 
   34000   -13878.643   -13878.643   -14020.052   -14020.052    273.56638    273.56638    47822.546    47822.546    1459.8326    1459.8326 
Loop time of 183.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.929 hours/ns, 5.454 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    | 182.4      | 182.4      | 182.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15068    | 0.15068    | 0.15068    |   0.0 |  0.08
Output  | 0.0002407  | 0.0002407  | 0.0002407  |   0.0 |  0.00
Modify  | 0.6986     | 0.6986     | 0.6986     |   0.0 |  0.38
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:        5838.00 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248094.0 ave      248094 max      248094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248094
Ave neighs/atom = 62.023500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.826904164523, Press = 1.60934588113278
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13878.643   -13878.643   -14020.052   -14020.052    273.56638    273.56638    47822.546    47822.546    1459.8326    1459.8326 
   35000   -13879.449   -13879.449   -14020.924   -14020.924    273.69197    273.69197    47855.588    47855.588    365.87762    365.87762 
Loop time of 181.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.280 hours/ns, 5.525 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    | 180.07     | 180.07     | 180.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14885    | 0.14885    | 0.14885    |   0.0 |  0.08
Output  | 0.00017531 | 0.00017531 | 0.00017531 |   0.0 |  0.00
Modify  | 0.6877     | 0.6877     | 0.6877     |   0.0 |  0.38
Other   |            | 0.09857    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      249196.0 ave      249196 max      249196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249196
Ave neighs/atom = 62.299000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.823650224685, Press = 0.433993557202319
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13879.449   -13879.449   -14020.924   -14020.924    273.69197    273.69197    47855.588    47855.588    365.87762    365.87762 
   36000   -13876.857   -13876.857    -14016.89    -14016.89    270.90458    270.90458    47897.978    47897.978   -508.42935   -508.42935 
Loop time of 182.175 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.474 ns/day, 50.604 hours/ns, 5.489 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    | 181.23     | 181.23     | 181.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14845    | 0.14845    | 0.14845    |   0.0 |  0.08
Output  | 0.00031377 | 0.00031377 | 0.00031377 |   0.0 |  0.00
Modify  | 0.6928     | 0.6928     | 0.6928     |   0.0 |  0.38
Other   |            | 0.09886    |            |       |  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:      248702.0 ave      248702 max      248702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248702
Ave neighs/atom = 62.175500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.806639368854, Press = 0.526447474628215
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13876.857   -13876.857    -14016.89    -14016.89    270.90458    270.90458    47897.978    47897.978   -508.42935   -508.42935 
   37000   -13876.471   -13876.471   -14016.544   -14016.544    270.97983    270.97983    47890.614    47890.614   -214.02699   -214.02699 
Loop time of 179.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 49.966 hours/ns, 5.559 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    | 178.95     | 178.95     | 178.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14882    | 0.14882    | 0.14882    |   0.0 |  0.08
Output  | 0.00017597 | 0.00017597 | 0.00017597 |   0.0 |  0.00
Modify  | 0.68169    | 0.68169    | 0.68169    |   0.0 |  0.38
Other   |            | 0.09929    |            |       |  0.06

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:      248238.0 ave      248238 max      248238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248238
Ave neighs/atom = 62.059500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.873019862511, Press = 1.56635898646532
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13876.471   -13876.471   -14016.544   -14016.544    270.97983    270.97983    47890.614    47890.614   -214.02699   -214.02699 
   38000   -13876.567   -13876.567   -14018.572   -14018.572    274.71921    274.71921    47861.495    47861.495    515.50315    515.50315 
Loop time of 180.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.073 hours/ns, 5.547 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    | 179.33     | 179.33     | 179.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14998    | 0.14998    | 0.14998    |   0.0 |  0.08
Output  | 0.00017595 | 0.00017595 | 0.00017595 |   0.0 |  0.00
Modify  | 0.68144    | 0.68144    | 0.68144    |   0.0 |  0.38
Other   |            | 0.09843    |            |       |  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:      248288.0 ave      248288 max      248288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248288
Ave neighs/atom = 62.072000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.893018577424, Press = 0.661407329578219
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13876.567   -13876.567   -14018.572   -14018.572    274.71921    274.71921    47861.495    47861.495    515.50315    515.50315 
   39000   -13875.256   -13875.256   -14017.992   -14017.992    276.13101    276.13101    47905.909    47905.909   -780.73566   -780.73566 
Loop time of 180.216 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.060 hours/ns, 5.549 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    | 179.29     | 179.29     | 179.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14713    | 0.14713    | 0.14713    |   0.0 |  0.08
Output  | 0.00017594 | 0.00017594 | 0.00017594 |   0.0 |  0.00
Modify  | 0.68133    | 0.68133    | 0.68133    |   0.0 |  0.38
Other   |            | 0.0985     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5835.00 ave        5835 max        5835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248668.0 ave      248668 max      248668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248668
Ave neighs/atom = 62.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.953157594966, Press = 1.016615097438
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13875.256   -13875.256   -14017.992   -14017.992    276.13101    276.13101    47905.909    47905.909   -780.73566   -780.73566 
   40000   -13880.134   -13880.134   -14019.542   -14019.542    269.69368    269.69368    47841.444    47841.444    887.90907    887.90907 
Loop time of 182.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.472 ns/day, 50.811 hours/ns, 5.467 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    | 181.98     | 181.98     | 181.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14935    | 0.14935    | 0.14935    |   0.0 |  0.08
Output  | 0.00018522 | 0.00018522 | 0.00018522 |   0.0 |  0.00
Modify  | 0.69672    | 0.69672    | 0.69672    |   0.0 |  0.38
Other   |            | 0.09871    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248222.0 ave      248222 max      248222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248222
Ave neighs/atom = 62.055500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.96848914182, Press = 1.88681007969217
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13880.134   -13880.134   -14019.542   -14019.542    269.69368    269.69368    47841.444    47841.444    887.90907    887.90907 
   41000   -13875.934   -13875.934   -14019.637   -14019.637    278.00249    278.00249    47805.951    47805.951    1895.3814    1895.3814 
Loop time of 180.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.201 hours/ns, 5.533 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    | 179.79     | 179.79     | 179.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14691    | 0.14691    | 0.14691    |   0.0 |  0.08
Output  | 0.00048985 | 0.00048985 | 0.00048985 |   0.0 |  0.00
Modify  | 0.6845     | 0.6845     | 0.6845     |   0.0 |  0.38
Other   |            | 0.09854    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248806.0 ave      248806 max      248806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248806
Ave neighs/atom = 62.201500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.01710857144, Press = -0.486839829524457
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13875.934   -13875.934   -14019.637   -14019.637    278.00249    278.00249    47805.951    47805.951    1895.3814    1895.3814 
   42000   -13879.611   -13879.611    -14019.74    -14019.74    271.08888    271.08888    47951.854    47951.854   -2391.0177   -2391.0177 
Loop time of 182.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.561 hours/ns, 5.494 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    | 181.08     | 181.08     | 181.08     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.149      | 0.149      | 0.149      |   0.0 |  0.08
Output  | 0.00017852 | 0.00017852 | 0.00017852 |   0.0 |  0.00
Modify  | 0.69488    | 0.69488    | 0.69488    |   0.0 |  0.38
Other   |            | 0.09873    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5836.00 ave        5836 max        5836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      249672.0 ave      249672 max      249672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249672
Ave neighs/atom = 62.418000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.043446658203, Press = -0.334317145497638
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13879.611   -13879.611    -14019.74    -14019.74    271.08888    271.08888    47951.854    47951.854   -2391.0177   -2391.0177 
   43000   -13871.898   -13871.898   -14014.653   -14014.653    276.16873    276.16873    47917.282    47917.282   -662.88499   -662.88499 
Loop time of 181.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.476 ns/day, 50.436 hours/ns, 5.507 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    | 180.63     | 180.63     | 180.63     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14867    | 0.14867    | 0.14867    |   0.0 |  0.08
Output  | 0.00017425 | 0.00017425 | 0.00017425 |   0.0 |  0.00
Modify  | 0.69434    | 0.69434    | 0.69434    |   0.0 |  0.38
Other   |            | 0.09889    |            |       |  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:      247438.0 ave      247438 max      247438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247438
Ave neighs/atom = 61.859500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.075579409666, Press = 1.6815323781324
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13871.898   -13871.898   -14014.653   -14014.653    276.16873    276.16873    47917.282    47917.282   -662.88499   -662.88499 
   44000   -13878.787   -13878.787   -14019.048   -14019.048    271.34456    271.34456    47843.136    47843.136    860.29401    860.29401 
Loop time of 180.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.478 ns/day, 50.201 hours/ns, 5.533 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    | 179.79     | 179.79     | 179.79     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14815    | 0.14815    | 0.14815    |   0.0 |  0.08
Output  | 0.00017459 | 0.00017459 | 0.00017459 |   0.0 |  0.00
Modify  | 0.68534    | 0.68534    | 0.68534    |   0.0 |  0.38
Other   |            | 0.09902    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5836.00 ave        5836 max        5836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248104.0 ave      248104 max      248104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248104
Ave neighs/atom = 62.026000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.109748139707, Press = 1.08556340030266
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13878.787   -13878.787   -14019.048   -14019.048    271.34456    271.34456    47843.136    47843.136    860.29401    860.29401 
   45000   -13875.186   -13875.186   -14017.082   -14017.082    274.50704    274.50704    47901.451    47901.451   -474.45783   -474.45783 
Loop time of 182.242 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.474 ns/day, 50.623 hours/ns, 5.487 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    | 181.3      | 181.3      | 181.3      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14919    | 0.14919    | 0.14919    |   0.0 |  0.08
Output  | 0.00017623 | 0.00017623 | 0.00017623 |   0.0 |  0.00
Modify  | 0.69163    | 0.69163    | 0.69163    |   0.0 |  0.38
Other   |            | 0.09917    |            |       |  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:      248852.0 ave      248852 max      248852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248852
Ave neighs/atom = 62.213000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.10335660317, Press = 0.449720027602211
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13875.186   -13875.186   -14017.082   -14017.082    274.50704    274.50704    47901.451    47901.451   -474.45783   -474.45783 
   46000   -13878.642   -13878.642   -14021.381   -14021.381     276.1395     276.1395    47893.885    47893.885   -757.16034   -757.16034 
Loop time of 181.749 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.486 hours/ns, 5.502 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    | 180.82     | 180.82     | 180.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14818    | 0.14818    | 0.14818    |   0.0 |  0.08
Output  | 0.00017689 | 0.00017689 | 0.00017689 |   0.0 |  0.00
Modify  | 0.687      | 0.687      | 0.687      |   0.0 |  0.38
Other   |            | 0.09857    |            |       |  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:      248108.0 ave      248108 max      248108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248108
Ave neighs/atom = 62.027000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.115788904846, Press = 1.24558722506468
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13878.642   -13878.642   -14021.381   -14021.381     276.1395     276.1395    47893.885    47893.885   -757.16034   -757.16034 
   47000   -13872.965   -13872.965   -14015.617   -14015.617    275.97004    275.97004    47823.442    47823.442     1928.952     1928.952 
Loop time of 181.124 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.312 hours/ns, 5.521 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    | 180.19     | 180.19     | 180.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14796    | 0.14796    | 0.14796    |   0.0 |  0.08
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.689      | 0.689      | 0.689      |   0.0 |  0.38
Other   |            | 0.09838    |            |       |  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:      248164.0 ave      248164 max      248164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248164
Ave neighs/atom = 62.041000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.118247764919, Press = 1.19196371955691
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13872.965   -13872.965   -14015.617   -14015.617    275.97004    275.97004    47823.442    47823.442     1928.952     1928.952 
   48000   -13876.216   -13876.216   -14017.029   -14017.029    272.41086    272.41086    47892.407    47892.407   -291.50323   -291.50323 
Loop time of 182.07 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.575 hours/ns, 5.492 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    | 181.13     | 181.13     | 181.13     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14771    | 0.14771    | 0.14771    |   0.0 |  0.08
Output  | 0.00023119 | 0.00023119 | 0.00023119 |   0.0 |  0.00
Modify  | 0.6933     | 0.6933     | 0.6933     |   0.0 |  0.38
Other   |            | 0.09941    |            |       |  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:      249576.0 ave      249576 max      249576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249576
Ave neighs/atom = 62.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.108101325184, Press = -0.370311018806216
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13876.216   -13876.216   -14017.029   -14017.029    272.41086    272.41086    47892.407    47892.407   -291.50323   -291.50323 
   49000   -13882.525   -13882.525   -14021.044   -14021.044    267.97487    267.97487     47901.33     47901.33   -1006.4709   -1006.4709 
Loop time of 181.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.323 hours/ns, 5.520 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    | 180.23     | 180.23     | 180.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14793    | 0.14793    | 0.14793    |   0.0 |  0.08
Output  | 0.00018014 | 0.00018014 | 0.00018014 |   0.0 |  0.00
Modify  | 0.687      | 0.687      | 0.687      |   0.0 |  0.38
Other   |            | 0.09904    |            |       |  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:      248010.0 ave      248010 max      248010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248010
Ave neighs/atom = 62.002500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.096273235117, Press = 1.37707713431944
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13882.525   -13882.525   -14021.044   -14021.044    267.97487    267.97487     47901.33     47901.33   -1006.4709   -1006.4709 
   50000    -13876.02    -13876.02   -14017.004   -14017.004     272.7423     272.7423    47832.636    47832.636    1398.0189    1398.0189 
Loop time of 182.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.474 ns/day, 50.602 hours/ns, 5.489 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    | 181.23     | 181.23     | 181.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14887    | 0.14887    | 0.14887    |   0.0 |  0.08
Output  | 0.00017956 | 0.00017956 | 0.00017956 |   0.0 |  0.00
Modify  | 0.69239    | 0.69239    | 0.69239    |   0.0 |  0.38
Other   |            | 0.09775    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5838.00 ave        5838 max        5838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248002.0 ave      248002 max      248002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248002
Ave neighs/atom = 62.000500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.063691946254, Press = 0.895456562736634
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -13876.02    -13876.02   -14017.004   -14017.004     272.7423     272.7423    47832.636    47832.636    1398.0189    1398.0189 
   51000   -13878.737   -13878.737   -14018.735   -14018.735    270.83486    270.83486     47870.99     47870.99    107.77419    107.77419 
Loop time of 183.284 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.471 ns/day, 50.912 hours/ns, 5.456 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    | 182.34     | 182.34     | 182.34     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14997    | 0.14997    | 0.14997    |   0.0 |  0.08
Output  | 0.00017811 | 0.00017811 | 0.00017811 |   0.0 |  0.00
Modify  | 0.69563    | 0.69563    | 0.69563    |   0.0 |  0.38
Other   |            | 0.09886    |            |       |  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:      249260.0 ave      249260 max      249260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249260
Ave neighs/atom = 62.315000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.052626796386, Press = 0.609077120686989
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13878.737   -13878.737   -14018.735   -14018.735    270.83486    270.83486     47870.99     47870.99    107.77419    107.77419 
   52000   -13875.716   -13875.716   -14017.995   -14017.995    275.24836    275.24836    47888.023    47888.023   -261.25893   -261.25893 
Loop time of 182.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.572 hours/ns, 5.493 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    | 181.12     | 181.12     | 181.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1491     | 0.1491     | 0.1491     |   0.0 |  0.08
Output  | 0.00017681 | 0.00017681 | 0.00017681 |   0.0 |  0.00
Modify  | 0.68935    | 0.68935    | 0.68935    |   0.0 |  0.38
Other   |            | 0.0984     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248486.0 ave      248486 max      248486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248486
Ave neighs/atom = 62.121500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.070318181722, Press = 0.494361741151561
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13875.716   -13875.716   -14017.995   -14017.995    275.24836    275.24836    47888.023    47888.023   -261.25893   -261.25893 
   53000   -13881.187   -13881.187   -14020.922   -14020.922     270.3261     270.3261    47887.155    47887.155   -702.00864   -702.00864 
Loop time of 179.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.482 ns/day, 49.819 hours/ns, 5.576 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    | 178.42     | 178.42     | 178.42     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14775    | 0.14775    | 0.14775    |   0.0 |  0.08
Output  | 0.00017781 | 0.00017781 | 0.00017781 |   0.0 |  0.00
Modify  | 0.68048    | 0.68048    | 0.68048    |   0.0 |  0.38
Other   |            | 0.0981     |            |       |  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:      248402.0 ave      248402 max      248402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248402
Ave neighs/atom = 62.100500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.073709814304, Press = 0.633320237987234
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13881.187   -13881.187   -14020.922   -14020.922     270.3261     270.3261    47887.155    47887.155   -702.00864   -702.00864 
   54000   -13874.677   -13874.677   -14017.298   -14017.298    275.90975    275.90975    47873.992    47873.992    231.61297    231.61297 
Loop time of 182.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.472 ns/day, 50.806 hours/ns, 5.467 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    | 181.95     | 181.95     | 181.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14898    | 0.14898    | 0.14898    |   0.0 |  0.08
Output  | 0.00022647 | 0.00022647 | 0.00022647 |   0.0 |  0.00
Modify  | 0.69736    | 0.69736    | 0.69736    |   0.0 |  0.38
Other   |            | 0.0991     |            |       |  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:      248438.0 ave      248438 max      248438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248438
Ave neighs/atom = 62.109500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.054407491433, Press = 1.26580047502367
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13874.677   -13874.677   -14017.298   -14017.298    275.90975    275.90975    47873.992    47873.992    231.61297    231.61297 
   55000   -13881.403   -13881.403    -14022.29    -14022.29    272.55466    272.55466     47846.72     47846.72    425.17133    425.17133 
Loop time of 181.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.476 ns/day, 50.397 hours/ns, 5.512 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    | 180.49     | 180.49     | 180.49     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1491     | 0.1491     | 0.1491     |   0.0 |  0.08
Output  | 0.00018083 | 0.00018083 | 0.00018083 |   0.0 |  0.00
Modify  | 0.69028    | 0.69028    | 0.69028    |   0.0 |  0.38
Other   |            | 0.098      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      248652.0 ave      248652 max      248652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248652
Ave neighs/atom = 62.163000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.031690142656, Press = 0.29983796917982
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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13881.403   -13881.403    -14022.29    -14022.29    272.55466    272.55466     47846.72     47846.72    425.17133    425.17133 
   56000   -13877.528   -13877.528   -14017.799   -14017.799    271.36281    271.36281    47911.676    47911.676   -1000.9062   -1000.9062 
Loop time of 181.944 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.540 hours/ns, 5.496 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    | 181        | 181        | 181        |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14893    | 0.14893    | 0.14893    |   0.0 |  0.08
Output  | 0.0001758  | 0.0001758  | 0.0001758  |   0.0 |  0.00
Modify  | 0.69286    | 0.69286    | 0.69286    |   0.0 |  0.38
Other   |            | 0.09919    |            |       |  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:      248756.0 ave      248756 max      248756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248756
Ave neighs/atom = 62.189000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
47875.4774012234

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0