# 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.917371571063995*${_u_distance}
variable latticeconst_converted equal 3.917371571063995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737157106399
Lattice spacing in x,y,z = 3.9173716 3.9173716 3.9173716
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 (39.173716 39.173716 39.173716)
  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 (39.173716 39.173716 39.173716)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongLee_2020_PtC__MO_716623333967_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 60115.200756225 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_716623333967_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22938.806   -22938.806       -23080       -23080       273.15       273.15    60115.201    60115.201    2508.6897    2508.6897 
    1000   -22789.496   -22789.496   -22940.184   -22940.184    291.51711    291.51711    60599.473    60599.473    489.84657    489.84657 
Loop time of 199.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.304 hours/ns, 5.023 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16343    | 0.16343    | 0.16343    |   0.0 |  0.08
Output  | 0.00026184 | 0.00026184 | 0.00026184 |   0.0 |  0.00
Modify  | 0.77433    | 0.77433    | 0.77433    |   0.0 |  0.39
Other   |            | 0.1016     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -22789.496   -22789.496   -22940.184   -22940.184    291.51711    291.51711    60599.473    60599.473    489.84657    489.84657 
    2000   -22797.661   -22797.661   -22943.729   -22943.729    282.57906    282.57906    60617.878    60617.878   -1031.1656   -1031.1656 
Loop time of 210.252 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.403 hours/ns, 4.756 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 209.24     | 209.24     | 209.24     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15672    | 0.15672    | 0.15672    |   0.0 |  0.07
Output  | 0.00021444 | 0.00021444 | 0.00021444 |   0.0 |  0.00
Modify  | 0.75023    | 0.75023    | 0.75023    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311980.0 ave      311980 max      311980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311980
Ave neighs/atom = 77.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -22797.661   -22797.661   -22943.729   -22943.729    282.57906    282.57906    60617.878    60617.878   -1031.1656   -1031.1656 
    3000   -22798.999   -22798.999   -22943.632   -22943.632    279.80238    279.80238    60631.018    60631.018   -1688.4898   -1688.4898 
Loop time of 190.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.453 ns/day, 52.966 hours/ns, 5.244 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    | 189.78     | 189.78     | 189.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1465     | 0.1465     | 0.1465     |   0.0 |  0.08
Output  | 0.000266   | 0.000266   | 0.000266   |   0.0 |  0.00
Modify  | 0.65413    | 0.65413    | 0.65413    |   0.0 |  0.34
Other   |            | 0.09261    |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22798.999   -22798.999   -22943.632   -22943.632    279.80238    279.80238    60631.018    60631.018   -1688.4898   -1688.4898 
    4000   -22794.726   -22794.726   -22942.034   -22942.034    284.97901    284.97901    60545.098    60545.098    2878.1285    2878.1285 
Loop time of 186.75 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.875 hours/ns, 5.355 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    | 185.88     | 185.88     | 185.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.144      | 0.144      | 0.144      |   0.0 |  0.08
Output  | 0.00025199 | 0.00025199 | 0.00025199 |   0.0 |  0.00
Modify  | 0.6373     | 0.6373     | 0.6373     |   0.0 |  0.34
Other   |            | 0.09124    |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -22794.726   -22794.726   -22942.034   -22942.034    284.97901    284.97901    60545.098    60545.098    2878.1285    2878.1285 
    5000   -22799.179   -22799.179   -22938.983   -22938.983      270.461      270.461    60605.748    60605.748    69.247515    69.247515 
Loop time of 187.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.965 hours/ns, 5.346 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    | 186.2      | 186.2      | 186.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14602    | 0.14602    | 0.14602    |   0.0 |  0.08
Output  | 0.00022286 | 0.00022286 | 0.00022286 |   0.0 |  0.00
Modify  | 0.63858    | 0.63858    | 0.63858    |   0.0 |  0.34
Other   |            | 0.09171    |            |       |  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:      311986.0 ave      311986 max      311986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311986
Ave neighs/atom = 77.996500
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 = 275.945521795033, Press = 131.89677206937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -22799.179   -22799.179   -22938.983   -22938.983      270.461      270.461    60605.748    60605.748    69.247515    69.247515 
    6000   -22798.385   -22798.385   -22940.749   -22940.749    275.41297    275.41297    60617.017    60617.017   -588.31445   -588.31445 
Loop time of 187.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.145 hours/ns, 5.327 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.82     | 186.82     | 186.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14619    | 0.14619    | 0.14619    |   0.0 |  0.08
Output  | 0.00018457 | 0.00018457 | 0.00018457 |   0.0 |  0.00
Modify  | 0.66025    | 0.66025    | 0.66025    |   0.0 |  0.35
Other   |            | 0.09192    |            |       |  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:      311972.0 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 77.993000
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.532538318127, Press = 11.9032939219102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22798.385   -22798.385   -22940.749   -22940.749    275.41297    275.41297    60617.017    60617.017   -588.31445   -588.31445 
    7000     -22796.9     -22796.9   -22936.969   -22936.969    270.97172    270.97172    60582.704    60582.704    1460.3471    1460.3471 
Loop time of 204.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.779 hours/ns, 4.892 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    | 203.41     | 203.41     | 203.41     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15413    | 0.15413    | 0.15413    |   0.0 |  0.08
Output  | 0.00018592 | 0.00018592 | 0.00018592 |   0.0 |  0.00
Modify  | 0.74343    | 0.74343    | 0.74343    |   0.0 |  0.36
Other   |            | 0.09823    |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
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.027414982405, Press = 16.8216980512035
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000     -22796.9     -22796.9   -22936.969   -22936.969    270.97172    270.97172    60582.704    60582.704    1460.3471    1460.3471 
    8000   -22797.826   -22797.826   -22937.808   -22937.808    270.80583    270.80583    60621.234    60621.234   -312.39406   -312.39406 
Loop time of 187.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.975 hours/ns, 5.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.22     | 186.22     | 186.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14347    | 0.14347    | 0.14347    |   0.0 |  0.08
Output  | 0.00018036 | 0.00018036 | 0.00018036 |   0.0 |  0.00
Modify  | 0.65917    | 0.65917    | 0.65917    |   0.0 |  0.35
Other   |            | 0.09176    |            |       |  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:      311970.0 ave      311970 max      311970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
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.352303533151, Press = -0.0165826140346378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22797.826   -22797.826   -22937.808   -22937.808    270.80583    270.80583    60621.234    60621.234   -312.39406   -312.39406 
    9000   -22801.061   -22801.061   -22941.336   -22941.336    271.37237    271.37237    60609.338    60609.338   -316.34084   -316.34084 
Loop time of 186.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.464 ns/day, 51.736 hours/ns, 5.369 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    | 185.36     | 185.36     | 185.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14224    | 0.14224    | 0.14224    |   0.0 |  0.08
Output  | 0.00018224 | 0.00018224 | 0.00018224 |   0.0 |  0.00
Modify  | 0.65656    | 0.65656    | 0.65656    |   0.0 |  0.35
Other   |            | 0.09212    |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
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.989590354352, Press = 13.8872115327723
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22801.061   -22801.061   -22941.336   -22941.336    271.37237    271.37237    60609.338    60609.338   -316.34084   -316.34084 
   10000   -22795.713   -22795.713   -22935.439   -22935.439     270.3097     270.3097    60664.137    60664.137   -2085.7079   -2085.7079 
Loop time of 186.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.818 hours/ns, 5.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.65     | 185.65     | 185.65     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1448     | 0.1448     | 0.1448     |   0.0 |  0.08
Output  | 0.00018728 | 0.00018728 | 0.00018728 |   0.0 |  0.00
Modify  | 0.65806    | 0.65806    | 0.65806    |   0.0 |  0.35
Other   |            | 0.09126    |            |       |  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:      311974.0 ave      311974 max      311974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
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.998498096246, Press = 2.08841126402554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22795.713   -22795.713   -22935.439   -22935.439     270.3097     270.3097    60664.137    60664.137   -2085.7079   -2085.7079 
   11000   -22804.195   -22804.195   -22943.267   -22943.267    269.04346    269.04346    60605.468    60605.468   -380.70535   -380.70535 
Loop time of 186.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.868 hours/ns, 5.355 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    | 185.83     | 185.83     | 185.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14459    | 0.14459    | 0.14459    |   0.0 |  0.08
Output  | 0.00018157 | 0.00018157 | 0.00018157 |   0.0 |  0.00
Modify  | 0.65862    | 0.65862    | 0.65862    |   0.0 |  0.35
Other   |            | 0.09132    |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
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.80283537352, Press = -1.61724276379452
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22804.195   -22804.195   -22943.267   -22943.267    269.04346    269.04346    60605.468    60605.468   -380.70535   -380.70535 
   12000   -22799.916   -22799.916   -22938.619   -22938.619    268.33075    268.33075    60580.525    60580.525    1426.9954    1426.9954 
Loop time of 186.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.939 hours/ns, 5.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.09     | 186.09     | 186.09     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14393    | 0.14393    | 0.14393    |   0.0 |  0.08
Output  | 0.00018337 | 0.00018337 | 0.00018337 |   0.0 |  0.00
Modify  | 0.65965    | 0.65965    | 0.65965    |   0.0 |  0.35
Other   |            | 0.09198    |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.812840537307, Press = -0.386289773634557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22799.916   -22799.916   -22938.619   -22938.619    268.33075    268.33075    60580.525    60580.525    1426.9954    1426.9954 
   13000   -22799.099   -22799.099   -22941.518   -22941.518    275.51904    275.51904    60590.703    60590.703    567.83222    567.83222 
Loop time of 203.848 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.624 hours/ns, 4.906 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    | 202.84     | 202.84     | 202.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.154      | 0.154      | 0.154      |   0.0 |  0.08
Output  | 0.00017985 | 0.00017985 | 0.00017985 |   0.0 |  0.00
Modify  | 0.75196    | 0.75196    | 0.75196    |   0.0 |  0.37
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:      311988.0 ave      311988 max      311988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311988
Ave neighs/atom = 77.997000
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.863169926096, Press = -0.266371175960308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -22799.099   -22799.099   -22941.518   -22941.518    275.51904    275.51904    60590.703    60590.703    567.83222    567.83222 
   14000   -22794.598   -22794.598   -22939.184   -22939.184    279.71107    279.71107    60568.155    60568.155    2049.3095    2049.3095 
Loop time of 186.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.846 hours/ns, 5.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.75     | 185.75     | 185.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14496    | 0.14496    | 0.14496    |   0.0 |  0.08
Output  | 0.00017764 | 0.00017764 | 0.00017764 |   0.0 |  0.00
Modify  | 0.658      | 0.658      | 0.658      |   0.0 |  0.35
Other   |            | 0.09127    |            |       |  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:      311974.0 ave      311974 max      311974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
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.108603026454, Press = 2.64829006604915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22794.598   -22794.598   -22939.184   -22939.184    279.71107    279.71107    60568.155    60568.155    2049.3095    2049.3095 
   15000   -22798.449   -22798.449   -22939.495   -22939.495    272.86218    272.86218    60612.918    60612.918    -157.2807    -157.2807 
Loop time of 186.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.799 hours/ns, 5.363 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    | 185.58     | 185.58     | 185.58     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14331    | 0.14331    | 0.14331    |   0.0 |  0.08
Output  | 0.00051383 | 0.00051383 | 0.00051383 |   0.0 |  0.00
Modify  | 0.65934    | 0.65934    | 0.65934    |   0.0 |  0.35
Other   |            | 0.09153    |            |       |  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:      311980.0 ave      311980 max      311980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311980
Ave neighs/atom = 77.995000
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.090713875965, Press = 4.21754596361593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22798.449   -22798.449   -22939.495   -22939.495    272.86218    272.86218    60612.918    60612.918    -157.2807    -157.2807 
   16000   -22799.502   -22799.502   -22939.428   -22939.428    270.69631    270.69631    60631.022    60631.022   -1131.5391   -1131.5391 
Loop time of 186.855 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.904 hours/ns, 5.352 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    | 185.96     | 185.96     | 185.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14448    | 0.14448    | 0.14448    |   0.0 |  0.08
Output  | 0.00017866 | 0.00017866 | 0.00017866 |   0.0 |  0.00
Modify  | 0.66174    | 0.66174    | 0.66174    |   0.0 |  0.35
Other   |            | 0.09086    |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.034690293738, Press = 1.13510071570796
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22799.502   -22799.502   -22939.428   -22939.428    270.69631    270.69631    60631.022    60631.022   -1131.5391   -1131.5391 
   17000   -22799.776   -22799.776   -22942.199   -22942.199    275.52658    275.52658    60643.946    60643.946   -2062.5876   -2062.5876 
Loop time of 186.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.918 hours/ns, 5.350 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    | 186.01     | 186.01     | 186.01     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14428    | 0.14428    | 0.14428    |   0.0 |  0.08
Output  | 0.00018124 | 0.00018124 | 0.00018124 |   0.0 |  0.00
Modify  | 0.66203    | 0.66203    | 0.66203    |   0.0 |  0.35
Other   |            | 0.09156    |            |       |  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:      311978.0 ave      311978 max      311978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311978
Ave neighs/atom = 77.994500
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.957207941737, Press = -0.419635613371433
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22799.776   -22799.776   -22942.199   -22942.199    275.52658    275.52658    60643.946    60643.946   -2062.5876   -2062.5876 
   18000   -22797.638   -22797.638   -22937.422   -22937.422    270.42301    270.42301    60593.526    60593.526      903.487      903.487 
Loop time of 186.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.917 hours/ns, 5.350 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    | 186.01     | 186.01     | 186.01     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14352    | 0.14352    | 0.14352    |   0.0 |  0.08
Output  | 0.00018373 | 0.00018373 | 0.00018373 |   0.0 |  0.00
Modify  | 0.65947    | 0.65947    | 0.65947    |   0.0 |  0.35
Other   |            | 0.09146    |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.923876033899, Press = -0.148601079408591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22797.638   -22797.638   -22937.422   -22937.422    270.42301    270.42301    60593.526    60593.526      903.487      903.487 
   19000   -22800.856   -22800.856   -22940.769   -22940.769    270.67092    270.67092    60573.783    60573.783    1429.7282    1429.7282 
Loop time of 186.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.885 hours/ns, 5.354 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    | 185.89     | 185.89     | 185.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14475    | 0.14475    | 0.14475    |   0.0 |  0.08
Output  | 0.0001821  | 0.0001821  | 0.0001821  |   0.0 |  0.00
Modify  | 0.66146    | 0.66146    | 0.66146    |   0.0 |  0.35
Other   |            | 0.09138    |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.820069966082, Press = 3.56959930890029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -22800.856   -22800.856   -22940.769   -22940.769    270.67092    270.67092    60573.783    60573.783    1429.7282    1429.7282 
   20000   -22801.573   -22801.573   -22939.345   -22939.345    266.52938    266.52938     60643.94     60643.94   -1718.7511   -1718.7511 
Loop time of 193.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.866 hours/ns, 5.157 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    | 192.97     | 192.97     | 192.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14879    | 0.14879    | 0.14879    |   0.0 |  0.08
Output  | 0.0001873  | 0.0001873  | 0.0001873  |   0.0 |  0.00
Modify  | 0.69921    | 0.69921    | 0.69921    |   0.0 |  0.36
Other   |            | 0.09485    |            |       |  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:      311974.0 ave      311974 max      311974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
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.840847354144, Press = 1.15491568021991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22801.573   -22801.573   -22939.345   -22939.345    266.52938    266.52938     60643.94     60643.94   -1718.7511   -1718.7511 
   21000   -22798.599   -22798.599   -22939.879   -22939.879    273.31511    273.31511    60613.716    60613.716   -366.42155   -366.42155 
Loop time of 214.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.656 hours/ns, 4.656 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    | 213.69     | 213.69     | 213.69     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16139    | 0.16139    | 0.16139    |   0.0 |  0.08
Output  | 0.00027901 | 0.00027901 | 0.00027901 |   0.0 |  0.00
Modify  | 0.80531    | 0.80531    | 0.80531    |   0.0 |  0.37
Other   |            | 0.102      |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
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.791351380498, Press = 1.77957423313257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22798.599   -22798.599   -22939.879   -22939.879    273.31511    273.31511    60613.716    60613.716   -366.42155   -366.42155 
   22000   -22799.812   -22799.812   -22940.261   -22940.261    271.70743    271.70743    60624.596    60624.596   -952.89872   -952.89872 
Loop time of 213.792 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.387 hours/ns, 4.677 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.75     | 212.75     | 212.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15996    | 0.15996    | 0.15996    |   0.0 |  0.07
Output  | 0.00023387 | 0.00023387 | 0.00023387 |   0.0 |  0.00
Modify  | 0.78438    | 0.78438    | 0.78438    |   0.0 |  0.37
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.836520676854, Press = 0.934139070537525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22799.812   -22799.812   -22940.261   -22940.261    271.70743    271.70743    60624.596    60624.596   -952.89872   -952.89872 
   23000   -22798.115   -22798.115   -22939.357   -22939.357    273.24099    273.24099     60623.51     60623.51    -703.2121    -703.2121 
Loop time of 198.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.256 hours/ns, 5.027 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.96     | 197.96     | 197.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15089    | 0.15089    | 0.15089    |   0.0 |  0.08
Output  | 0.00018432 | 0.00018432 | 0.00018432 |   0.0 |  0.00
Modify  | 0.71746    | 0.71746    | 0.71746    |   0.0 |  0.36
Other   |            | 0.09553    |            |       |  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:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.883235082816, Press = -0.361119284778915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22798.115   -22798.115   -22939.357   -22939.357    273.24099    273.24099     60623.51     60623.51    -703.2121    -703.2121 
   24000     -22793.5     -22793.5   -22934.377   -22934.377    272.53597    272.53597    60649.689    60649.689   -1233.4841   -1233.4841 
Loop time of 220.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.359 hours/ns, 4.527 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    | 219.8      | 219.8      | 219.8      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16447    | 0.16447    | 0.16447    |   0.0 |  0.07
Output  | 0.00018099 | 0.00018099 | 0.00018099 |   0.0 |  0.00
Modify  | 0.82901    | 0.82901    | 0.82901    |   0.0 |  0.38
Other   |            | 0.1042     |            |       |  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:      311988.0 ave      311988 max      311988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311988
Ave neighs/atom = 77.997000
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.9712552807, Press = -0.489806171582009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000     -22793.5     -22793.5   -22934.377   -22934.377    272.53597    272.53597    60649.689    60649.689   -1233.4841   -1233.4841 
   25000   -22802.575   -22802.575   -22942.569   -22942.569    270.82806    270.82806    60566.032    60566.032    1464.9359    1464.9359 
Loop time of 218.66 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.739 hours/ns, 4.573 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    | 217.57     | 217.57     | 217.57     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16414    | 0.16414    | 0.16414    |   0.0 |  0.08
Output  | 0.00024828 | 0.00024828 | 0.00024828 |   0.0 |  0.00
Modify  | 0.81652    | 0.81652    | 0.81652    |   0.0 |  0.37
Other   |            | 0.1042     |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.964821131415, Press = -0.206512957575267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22802.575   -22802.575   -22942.569   -22942.569    270.82806    270.82806    60566.032    60566.032    1464.9359    1464.9359 
   26000   -22798.926   -22798.926   -22937.755   -22937.755    268.57265    268.57265    60573.611    60573.611    1800.7417    1800.7417 
Loop time of 219.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.911 hours/ns, 4.560 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    | 218.19     | 218.19     | 218.19     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16465    | 0.16465    | 0.16465    |   0.0 |  0.08
Output  | 0.00018309 | 0.00018309 | 0.00018309 |   0.0 |  0.00
Modify  | 0.82443    | 0.82443    | 0.82443    |   0.0 |  0.38
Other   |            | 0.1046     |            |       |  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:      311986.0 ave      311986 max      311986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311986
Ave neighs/atom = 77.996500
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.982614877647, Press = 1.41200107785363
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -22798.926   -22798.926   -22937.755   -22937.755    268.57265    268.57265    60573.611    60573.611    1800.7417    1800.7417 
   27000   -22800.011   -22800.011   -22941.163   -22941.163    273.06952    273.06952    60620.935    60620.935   -750.42978   -750.42978 
Loop time of 219.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.920 hours/ns, 4.560 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    | 218.23     | 218.23     | 218.23     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16321    | 0.16321    | 0.16321    |   0.0 |  0.07
Output  | 0.00023826 | 0.00023826 | 0.00023826 |   0.0 |  0.00
Modify  | 0.81797    | 0.81797    | 0.81797    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.99030444638, Press = -0.576597855287788
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22800.011   -22800.011   -22941.163   -22941.163    273.06952    273.06952    60620.935    60620.935   -750.42978   -750.42978 
   28000   -22795.988   -22795.988   -22939.027   -22939.027    276.71742    276.71742    60662.737    60662.737   -2521.3327   -2521.3327 
Loop time of 218.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.754 hours/ns, 4.572 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    | 217.62     | 217.62     | 217.62     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16399    | 0.16399    | 0.16399    |   0.0 |  0.07
Output  | 0.00025556 | 0.00025556 | 0.00025556 |   0.0 |  0.00
Modify  | 0.82221    | 0.82221    | 0.82221    |   0.0 |  0.38
Other   |            | 0.1039     |            |       |  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:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.970693048013, Press = 0.483482638138595
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -22795.988   -22795.988   -22939.027   -22939.027    276.71742    276.71742    60662.737    60662.737   -2521.3327   -2521.3327 
   29000   -22803.603   -22803.603   -22938.982   -22938.982    261.90022    261.90022    60599.856    60599.856    369.66145    369.66145 
Loop time of 218.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.770 hours/ns, 4.571 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    | 217.68     | 217.68     | 217.68     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16351    | 0.16351    | 0.16351    |   0.0 |  0.07
Output  | 0.00023102 | 0.00023102 | 0.00023102 |   0.0 |  0.00
Modify  | 0.82766    | 0.82766    | 0.82766    |   0.0 |  0.38
Other   |            | 0.1036     |            |       |  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:      311970.0 ave      311970 max      311970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
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.937305584266, Press = -0.729665053580351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -22803.603   -22803.603   -22938.982   -22938.982    261.90022    261.90022    60599.856    60599.856    369.66145    369.66145 
   30000   -22795.532   -22795.532   -22940.559   -22940.559    280.56364    280.56364    60624.815    60624.815   -954.70038   -954.70038 
Loop time of 218.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.638 hours/ns, 4.581 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    | 217.23     | 217.23     | 217.23     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15896    | 0.15896    | 0.15896    |   0.0 |  0.07
Output  | 0.00017989 | 0.00017989 | 0.00017989 |   0.0 |  0.00
Modify  | 0.79949    | 0.79949    | 0.79949    |   0.0 |  0.37
Other   |            | 0.1024     |            |       |  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:      311984.0 ave      311984 max      311984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311984
Ave neighs/atom = 77.996000
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.889661367442, Press = 0.0119361706989012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22795.532   -22795.532   -22940.559   -22940.559    280.56364    280.56364    60624.815    60624.815   -954.70038   -954.70038 
   31000   -22801.779   -22801.779   -22941.513   -22941.513    270.32533    270.32533    60574.391    60574.391    1228.0894    1228.0894 
Loop time of 207.378 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.605 hours/ns, 4.822 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    | 206.36     | 206.36     | 206.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15561    | 0.15561    | 0.15561    |   0.0 |  0.08
Output  | 0.00022399 | 0.00022399 | 0.00022399 |   0.0 |  0.00
Modify  | 0.76319    | 0.76319    | 0.76319    |   0.0 |  0.37
Other   |            | 0.09899    |            |       |  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:      311972.0 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 77.993000
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.861818751856, Press = -0.672793463967783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22801.779   -22801.779   -22941.513   -22941.513    270.32533    270.32533    60574.391    60574.391    1228.0894    1228.0894 
   32000    -22796.87    -22796.87     -22938.6     -22938.6    274.18586    274.18586    60589.673    60589.673     906.5612     906.5612 
Loop time of 187.037 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.955 hours/ns, 5.347 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    | 186.14     | 186.14     | 186.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14605    | 0.14605    | 0.14605    |   0.0 |  0.08
Output  | 0.00018142 | 0.00018142 | 0.00018142 |   0.0 |  0.00
Modify  | 0.66254    | 0.66254    | 0.66254    |   0.0 |  0.35
Other   |            | 0.09168    |            |       |  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:      311976.0 ave      311976 max      311976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
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.899456585084, Press = 0.303366754798936
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -22796.87    -22796.87     -22938.6     -22938.6    274.18586    274.18586    60589.673    60589.673     906.5612     906.5612 
   33000   -22796.758   -22796.758   -22939.098   -22939.098    275.36566    275.36566    60550.202    60550.202    2750.1126    2750.1126 
Loop time of 206.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.411 hours/ns, 4.838 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    | 205.67     | 205.67     | 205.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1568     | 0.1568     | 0.1568     |   0.0 |  0.08
Output  | 0.00022296 | 0.00022296 | 0.00022296 |   0.0 |  0.00
Modify  | 0.75644    | 0.75644    | 0.75644    |   0.0 |  0.37
Other   |            | 0.09933    |            |       |  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:      311980.0 ave      311980 max      311980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311980
Ave neighs/atom = 77.995000
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.925336228005, Press = 2.46548805415805
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -22796.758   -22796.758   -22939.098   -22939.098    275.36566    275.36566    60550.202    60550.202    2750.1126    2750.1126 
   34000   -22798.902   -22798.902   -22937.925   -22937.925    268.94935    268.94935    60600.804    60600.804    456.87858    456.87858 
Loop time of 191.284 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.134 hours/ns, 5.228 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    | 190.36     | 190.36     | 190.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14754    | 0.14754    | 0.14754    |   0.0 |  0.08
Output  | 0.00021988 | 0.00021988 | 0.00021988 |   0.0 |  0.00
Modify  | 0.68721    | 0.68721    | 0.68721    |   0.0 |  0.36
Other   |            | 0.09347    |            |       |  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:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.947677767441, Press = 0.822446602275247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -22798.902   -22798.902   -22937.925   -22937.925    268.94935    268.94935    60600.804    60600.804    456.87858    456.87858 
   35000   -22796.617   -22796.617   -22941.519   -22941.519    280.32253    280.32253    60598.475    60598.475    194.48227    194.48227 
Loop time of 205.836 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.177 hours/ns, 4.858 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    | 204.83     | 204.83     | 204.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15561    | 0.15561    | 0.15561    |   0.0 |  0.08
Output  | 0.00018673 | 0.00018673 | 0.00018673 |   0.0 |  0.00
Modify  | 0.75267    | 0.75267    | 0.75267    |   0.0 |  0.37
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:        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:      311972.0 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 77.993000
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.973889988481, Press = 0.744940403850846
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -22796.617   -22796.617   -22941.519   -22941.519    280.32253    280.32253    60598.475    60598.475    194.48227    194.48227 
   36000   -22796.454   -22796.454   -22937.365   -22937.365    272.60265    272.60265    60621.055    60621.055   -290.20931   -290.20931 
Loop time of 215.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.856 hours/ns, 4.641 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    | 214.41     | 214.41     | 214.41     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15913    | 0.15913    | 0.15913    |   0.0 |  0.07
Output  | 0.0001791  | 0.0001791  | 0.0001791  |   0.0 |  0.00
Modify  | 0.804      | 0.804      | 0.804      |   0.0 |  0.37
Other   |            | 0.1032     |            |       |  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:      311980.0 ave      311980 max      311980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311980
Ave neighs/atom = 77.995000
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.961368203538, Press = -0.891720099374033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -22796.454   -22796.454   -22937.365   -22937.365    272.60265    272.60265    60621.055    60621.055   -290.20931   -290.20931 
   37000   -22796.275   -22796.275   -22937.407   -22937.407    273.02904    273.02904    60611.942    60611.942    57.860377    57.860377 
Loop time of 210.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.425 hours/ns, 4.754 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    | 209.28     | 209.28     | 209.28     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15809    | 0.15809    | 0.15809    |   0.0 |  0.08
Output  | 0.00017959 | 0.00017959 | 0.00017959 |   0.0 |  0.00
Modify  | 0.78443    | 0.78443    | 0.78443    |   0.0 |  0.37
Other   |            | 0.1028     |            |       |  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:      311982.0 ave      311982 max      311982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311982
Ave neighs/atom = 77.995500
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.953659307433, Press = 0.529095129208615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -22796.275   -22796.275   -22937.407   -22937.407    273.02904    273.02904    60611.942    60611.942    57.860377    57.860377 
   38000   -22802.045   -22802.045   -22942.417   -22942.417    271.55888    271.55888    60585.151    60585.151     683.9636     683.9636 
Loop time of 210.259 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.405 hours/ns, 4.756 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    | 209.21     | 209.21     | 209.21     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15844    | 0.15844    | 0.15844    |   0.0 |  0.08
Output  | 0.00022188 | 0.00022188 | 0.00022188 |   0.0 |  0.00
Modify  | 0.78755    | 0.78755    | 0.78755    |   0.0 |  0.37
Other   |            | 0.1016     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311972.0 ave      311972 max      311972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311972
Ave neighs/atom = 77.993000
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.968927247257, Press = -0.362996723471375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -22802.045   -22802.045   -22942.417   -22942.417    271.55888    271.55888    60585.151    60585.151     683.9636     683.9636 
   39000   -22795.947   -22795.947   -22939.937   -22939.937    278.55913    278.55913    60583.908    60583.908     1063.754     1063.754 
Loop time of 218.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.769 hours/ns, 4.571 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    | 217.69     | 217.69     | 217.69     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16236    | 0.16236    | 0.16236    |   0.0 |  0.07
Output  | 0.00021853 | 0.00021853 | 0.00021853 |   0.0 |  0.00
Modify  | 0.81362    | 0.81362    | 0.81362    |   0.0 |  0.37
Other   |            | 0.1019     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311988.0 ave      311988 max      311988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311988
Ave neighs/atom = 77.997000
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.925131540557, Press = 0.643176737371491
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -22795.947   -22795.947   -22939.937   -22939.937    278.55913    278.55913    60583.908    60583.908     1063.754     1063.754 
   40000   -22798.987   -22798.987   -22938.642   -22938.642    270.17275    270.17275     60644.46     60644.46   -1638.1378   -1638.1378 
Loop time of 214.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.610 hours/ns, 4.660 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    | 213.54     | 213.54     | 213.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15998    | 0.15998    | 0.15998    |   0.0 |  0.07
Output  | 0.00018623 | 0.00018623 | 0.00018623 |   0.0 |  0.00
Modify  | 0.79646    | 0.79646    | 0.79646    |   0.0 |  0.37
Other   |            | 0.1024     |            |       |  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:      311986.0 ave      311986 max      311986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311986
Ave neighs/atom = 77.996500
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.915159763922, Press = -0.108734601276274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -22798.987   -22798.987   -22938.642   -22938.642    270.17275    270.17275     60644.46     60644.46   -1638.1378   -1638.1378 
   41000   -22796.845   -22796.845   -22938.637   -22938.637     274.3063     274.3063    60669.978    60669.978   -2834.1416   -2834.1416 
Loop time of 216.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.156 hours/ns, 4.618 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    | 215.5      | 215.5      | 215.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16045    | 0.16045    | 0.16045    |   0.0 |  0.07
Output  | 0.00047022 | 0.00047022 | 0.00047022 |   0.0 |  0.00
Modify  | 0.80311    | 0.80311    | 0.80311    |   0.0 |  0.37
Other   |            | 0.1016     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311976.0 ave      311976 max      311976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
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.908076064411, Press = -0.40747306652346
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -22796.845   -22796.845   -22938.637   -22938.637     274.3063     274.3063    60669.978    60669.978   -2834.1416   -2834.1416 
   42000   -22799.824   -22799.824   -22939.139   -22939.139     269.5136     269.5136    60598.042    60598.042     524.7606     524.7606 
Loop time of 186.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.932 hours/ns, 5.349 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.06     | 186.06     | 186.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14494    | 0.14494    | 0.14494    |   0.0 |  0.08
Output  | 0.00022057 | 0.00022057 | 0.00022057 |   0.0 |  0.00
Modify  | 0.66064    | 0.66064    | 0.66064    |   0.0 |  0.35
Other   |            | 0.09144    |            |       |  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:      311990.0 ave      311990 max      311990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
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.911470622567, Press = -0.347343910717942
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -22799.824   -22799.824   -22939.139   -22939.139     269.5136     269.5136    60598.042    60598.042     524.7606     524.7606 
   43000   -22795.765   -22795.765    -22938.03    -22938.03    275.22262    275.22262    60605.685    60605.685    284.97949    284.97949 
Loop time of 186.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.827 hours/ns, 5.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.68     | 185.68     | 185.68     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14508    | 0.14508    | 0.14508    |   0.0 |  0.08
Output  | 0.00018072 | 0.00018072 | 0.00018072 |   0.0 |  0.00
Modify  | 0.65866    | 0.65866    | 0.65866    |   0.0 |  0.35
Other   |            | 0.09191    |            |       |  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:      311976.0 ave      311976 max      311976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
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.915109390946, Press = -0.0799368463220288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -22795.765   -22795.765    -22938.03    -22938.03    275.22262    275.22262    60605.685    60605.685    284.97949    284.97949 
   44000   -22793.735   -22793.735   -22936.352   -22936.352    275.90304    275.90304    60612.031    60612.031    293.42005    293.42005 
Loop time of 213.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.204 hours/ns, 4.692 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    | 212.09     | 212.09     | 212.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15941    | 0.15941    | 0.15941    |   0.0 |  0.07
Output  | 0.00018641 | 0.00018641 | 0.00018641 |   0.0 |  0.00
Modify  | 0.78759    | 0.78759    | 0.78759    |   0.0 |  0.37
Other   |            | 0.1023     |            |       |  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:      311978.0 ave      311978 max      311978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311978
Ave neighs/atom = 77.994500
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.94008394361, Press = 0.58349752069629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -22793.735   -22793.735   -22936.352   -22936.352    275.90304    275.90304    60612.031    60612.031    293.42005    293.42005 
   45000   -22800.447   -22800.447   -22940.162   -22940.162    270.28851    270.28851    60583.757    60583.757    1005.9172    1005.9172 
Loop time of 217.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.553 hours/ns, 4.587 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    | 216.91     | 216.91     | 216.91     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16183    | 0.16183    | 0.16183    |   0.0 |  0.07
Output  | 0.00029236 | 0.00029236 | 0.00029236 |   0.0 |  0.00
Modify  | 0.81577    | 0.81577    | 0.81577    |   0.0 |  0.37
Other   |            | 0.1052     |            |       |  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:      311986.0 ave      311986 max      311986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311986
Ave neighs/atom = 77.996500
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.982130101058, Press = 0.665774060608685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -22800.447   -22800.447   -22940.162   -22940.162    270.28851    270.28851    60583.757    60583.757    1005.9172    1005.9172 
   46000   -22798.574   -22798.574   -22940.338   -22940.338    274.25157    274.25157    60662.736    60662.736   -2646.3309   -2646.3309 
Loop time of 219.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.929 hours/ns, 4.559 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 218.26     | 218.26     | 218.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16319    | 0.16319    | 0.16319    |   0.0 |  0.07
Output  | 0.00018622 | 0.00018622 | 0.00018622 |   0.0 |  0.00
Modify  | 0.81757    | 0.81757    | 0.81757    |   0.0 |  0.37
Other   |            | 0.1034     |            |       |  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:      311986.0 ave      311986 max      311986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311986
Ave neighs/atom = 77.996500
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
60608.0528957119

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0