# 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.620386697351933*${_u_distance}
variable latticeconst_converted equal 3.620386697351933*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62038669735193
Lattice spacing in x,y,z = 3.6203867 3.6203867 3.6203867
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.203867 36.203867 36.203867)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.203867 36.203867 36.203867)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 293.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -14008.467   -14008.467       -14160       -14160       293.15       293.15    47453.132    47453.132    3410.8486    3410.8486 
    1000   -13845.958   -13845.958   -14003.802   -14003.802    305.36028    305.36028    48207.383    48207.383    -2717.767    -2717.767 
Loop time of 77.9234 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.645 hours/ns, 12.833 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.518     | 77.518     | 77.518     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051367   | 0.051367   | 0.051367   |   0.0 |  0.07
Output  | 0.00022233 | 0.00022233 | 0.00022233 |   0.0 |  0.00
Modify  | 0.30631    | 0.30631    | 0.30631    |   0.0 |  0.39
Other   |            | 0.04748    |            |       |  0.06

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13845.958   -13845.958   -14003.802   -14003.802    305.36028    305.36028    48207.383    48207.383    -2717.767    -2717.767 
    2000   -13857.951   -13857.951   -14013.039   -14013.039    300.02884    300.02884    48087.375    48087.375    83.714708    83.714708 
Loop time of 79.6078 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.085 ns/day, 22.113 hours/ns, 12.562 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    | 79.217     | 79.217     | 79.217     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049088   | 0.049088   | 0.049088   |   0.0 |  0.06
Output  | 0.00024637 | 0.00024637 | 0.00024637 |   0.0 |  0.00
Modify  | 0.29323    | 0.29323    | 0.29323    |   0.0 |  0.37
Other   |            | 0.04832    |            |       |  0.06

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

Total # of neighbors = 310740
Ave neighs/atom = 77.685000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13857.951   -13857.951   -14013.039   -14013.039    300.02884    300.02884    48087.375    48087.375    83.714708    83.714708 
    3000   -13852.148   -13852.148   -14008.734   -14008.734    302.92583    302.92583    48126.288    48126.288   -552.07808   -552.07808 
Loop time of 79.5742 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.086 ns/day, 22.104 hours/ns, 12.567 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    | 79.185     | 79.185     | 79.185     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04894    | 0.04894    | 0.04894    |   0.0 |  0.06
Output  | 0.00013731 | 0.00013731 | 0.00013731 |   0.0 |  0.00
Modify  | 0.29271    | 0.29271    | 0.29271    |   0.0 |  0.37
Other   |            | 0.04762    |            |       |  0.06

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

Total # of neighbors = 311132
Ave neighs/atom = 77.783000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13852.148   -13852.148   -14008.734   -14008.734    302.92583    302.92583    48126.288    48126.288   -552.07808   -552.07808 
    4000   -13856.434   -13856.434   -14009.051   -14009.051    295.24884    295.24884    48126.144    48126.144   -681.09484   -681.09484 
Loop time of 79.6459 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.085 ns/day, 22.124 hours/ns, 12.556 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    | 79.258     | 79.258     | 79.258     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049077   | 0.049077   | 0.049077   |   0.0 |  0.06
Output  | 0.00013886 | 0.00013886 | 0.00013886 |   0.0 |  0.00
Modify  | 0.29224    | 0.29224    | 0.29224    |   0.0 |  0.37
Other   |            | 0.04644    |            |       |  0.06

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

Total # of neighbors = 310906
Ave neighs/atom = 77.726500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.434   -13856.434   -14009.051   -14009.051    295.24884    295.24884    48126.144    48126.144   -681.09484   -681.09484 
    5000    -13855.18    -13855.18   -14009.555   -14009.555    298.64876    298.64876     48070.68     48070.68    877.21139    877.21139 
Loop time of 79.3093 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.089 ns/day, 22.030 hours/ns, 12.609 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    | 78.918     | 78.918     | 78.918     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048871   | 0.048871   | 0.048871   |   0.0 |  0.06
Output  | 0.00010589 | 0.00010589 | 0.00010589 |   0.0 |  0.00
Modify  | 0.29341    | 0.29341    | 0.29341    |   0.0 |  0.37
Other   |            | 0.04861    |            |       |  0.06

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

Total # of neighbors = 310916
Ave neighs/atom = 77.729000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 296.64975474448, Press = -156.133178065837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13855.18    -13855.18   -14009.555   -14009.555    298.64876    298.64876     48070.68     48070.68    877.21139    877.21139 
    6000   -13852.799   -13852.799   -14006.413   -14006.413    297.17565    297.17565    48191.171    48191.171   -2199.2176   -2199.2176 
Loop time of 79.5013 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.087 ns/day, 22.084 hours/ns, 12.578 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    | 79.104     | 79.104     | 79.104     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048729   | 0.048729   | 0.048729   |   0.0 |  0.06
Output  | 0.0001069  | 0.0001069  | 0.0001069  |   0.0 |  0.00
Modify  | 0.30185    | 0.30185    | 0.30185    |   0.0 |  0.38
Other   |            | 0.04668    |            |       |  0.06

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

Total # of neighbors = 310908
Ave neighs/atom = 77.727000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.622748965349, Press = -29.5232328517232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13852.799   -13852.799   -14006.413   -14006.413    297.17565    297.17565    48191.171    48191.171   -2199.2176   -2199.2176 
    7000   -13858.721   -13858.721   -14008.886   -14008.886    290.50393    290.50393    48051.903    48051.903    1442.1866    1442.1866 
Loop time of 79.6868 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.084 ns/day, 22.135 hours/ns, 12.549 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    | 79.284     | 79.284     | 79.284     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049541   | 0.049541   | 0.049541   |   0.0 |  0.06
Output  | 0.00010468 | 0.00010468 | 0.00010468 |   0.0 |  0.00
Modify  | 0.3046     | 0.3046     | 0.3046     |   0.0 |  0.38
Other   |            | 0.04809    |            |       |  0.06

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

Total # of neighbors = 310946
Ave neighs/atom = 77.736500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.078664709268, Press = 23.7583314893872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.721   -13858.721   -14008.886   -14008.886    290.50393    290.50393    48051.903    48051.903    1442.1866    1442.1866 
    8000   -13850.881   -13850.881   -14004.559   -14004.559    297.30118    297.30118    48127.784    48127.784   -231.45886   -231.45886 
Loop time of 79.1672 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.091 ns/day, 21.991 hours/ns, 12.632 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    | 78.772     | 78.772     | 78.772     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048564   | 0.048564   | 0.048564   |   0.0 |  0.06
Output  | 0.00010429 | 0.00010429 | 0.00010429 |   0.0 |  0.00
Modify  | 0.30051    | 0.30051    | 0.30051    |   0.0 |  0.38
Other   |            | 0.04623    |            |       |  0.06

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

Total # of neighbors = 311136
Ave neighs/atom = 77.784000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.306029184408, Press = -15.0738292797344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13850.881   -13850.881   -14004.559   -14004.559    297.30118    297.30118    48127.784    48127.784   -231.45886   -231.45886 
    9000   -13855.058   -13855.058   -14005.002   -14005.002    290.07667    290.07667    48120.883    48120.883   -248.97451   -248.97451 
Loop time of 78.7452 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.874 hours/ns, 12.699 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    | 78.359     | 78.359     | 78.359     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04749    | 0.04749    | 0.04749    |   0.0 |  0.06
Output  | 0.00010697 | 0.00010697 | 0.00010697 |   0.0 |  0.00
Modify  | 0.29554    | 0.29554    | 0.29554    |   0.0 |  0.38
Other   |            | 0.04333    |            |       |  0.06

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

Total # of neighbors = 310742
Ave neighs/atom = 77.685500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427142181958, Press = 4.65403597101004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.058   -13855.058   -14005.002   -14005.002    290.07667    290.07667    48120.883    48120.883   -248.97451   -248.97451 
   10000   -13855.333   -13855.333   -14006.755   -14006.755    292.93566    292.93566    48099.503    48099.503    265.15677    265.15677 
Loop time of 78.7504 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.875 hours/ns, 12.698 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    | 78.365     | 78.365     | 78.365     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047551   | 0.047551   | 0.047551   |   0.0 |  0.06
Output  | 0.00010126 | 0.00010126 | 0.00010126 |   0.0 |  0.00
Modify  | 0.29509    | 0.29509    | 0.29509    |   0.0 |  0.37
Other   |            | 0.043      |            |       |  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:      310804.0 ave      310804 max      310804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310804
Ave neighs/atom = 77.701000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.65323514044, Press = -3.90911328570083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.333   -13855.333   -14006.755   -14006.755    292.93566    292.93566    48099.503    48099.503    265.15677    265.15677 
   11000   -13849.271   -13849.271   -14006.978   -14006.978    305.09372    305.09372    48158.197    48158.197   -1322.1817   -1322.1817 
Loop time of 78.7602 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.878 hours/ns, 12.697 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    | 78.375     | 78.375     | 78.375     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047355   | 0.047355   | 0.047355   |   0.0 |  0.06
Output  | 0.00010645 | 0.00010645 | 0.00010645 |   0.0 |  0.00
Modify  | 0.29492    | 0.29492    | 0.29492    |   0.0 |  0.37
Other   |            | 0.04285    |            |       |  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:      310976.0 ave      310976 max      310976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310976
Ave neighs/atom = 77.744000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.671481279591, Press = 1.77157820809222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13849.271   -13849.271   -14006.978   -14006.978    305.09372    305.09372    48158.197    48158.197   -1322.1817   -1322.1817 
   12000   -13855.801   -13855.801   -14009.941   -14009.941    298.19397    298.19397    48038.573    48038.573    1809.6466    1809.6466 
Loop time of 79.0959 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.092 ns/day, 21.971 hours/ns, 12.643 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    | 78.701     | 78.701     | 78.701     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048537   | 0.048537   | 0.048537   |   0.0 |  0.06
Output  | 0.00010073 | 0.00010073 | 0.00010073 |   0.0 |  0.00
Modify  | 0.30018    | 0.30018    | 0.30018    |   0.0 |  0.38
Other   |            | 0.04555    |            |       |  0.06

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

Total # of neighbors = 310904
Ave neighs/atom = 77.726000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.867048674679, Press = -0.507067284027507
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.801   -13855.801   -14009.941   -14009.941    298.19397    298.19397    48038.573    48038.573    1809.6466    1809.6466 
   13000   -13853.503   -13853.503   -14005.738   -14005.738    294.50977    294.50977    48184.759    48184.759   -2049.1177   -2049.1177 
Loop time of 78.8215 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.096 ns/day, 21.895 hours/ns, 12.687 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    | 78.433     | 78.433     | 78.433     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047641   | 0.047641   | 0.047641   |   0.0 |  0.06
Output  | 0.00011727 | 0.00011727 | 0.00011727 |   0.0 |  0.00
Modify  | 0.2965     | 0.2965     | 0.2965     |   0.0 |  0.38
Other   |            | 0.04378    |            |       |  0.06

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

Total # of neighbors = 311164
Ave neighs/atom = 77.791000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.710884673851, Press = -4.73903529337362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.503   -13853.503   -14005.738   -14005.738    294.50977    294.50977    48184.759    48184.759   -2049.1177   -2049.1177 
   14000   -13859.249   -13859.249   -14009.047   -14009.047    289.79296    289.79296    48076.938    48076.938     770.5747     770.5747 
Loop time of 79.0922 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.092 ns/day, 21.970 hours/ns, 12.643 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    | 78.699     | 78.699     | 78.699     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048369   | 0.048369   | 0.048369   |   0.0 |  0.06
Output  | 0.00010607 | 0.00010607 | 0.00010607 |   0.0 |  0.00
Modify  | 0.29959    | 0.29959    | 0.29959    |   0.0 |  0.38
Other   |            | 0.04552    |            |       |  0.06

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

Total # of neighbors = 310830
Ave neighs/atom = 77.707500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.693161992893, Press = 2.96464189246678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.249   -13859.249   -14009.047   -14009.047    289.79296    289.79296    48076.938    48076.938     770.5747     770.5747 
   15000   -13852.529   -13852.529    -14006.31    -14006.31    297.49932    297.49932    48110.416    48110.416    79.910053    79.910053 
Loop time of 78.8228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.096 ns/day, 21.895 hours/ns, 12.687 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    | 78.435     | 78.435     | 78.435     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047465   | 0.047465   | 0.047465   |   0.0 |  0.06
Output  | 0.00010523 | 0.00010523 | 0.00010523 |   0.0 |  0.00
Modify  | 0.2964     | 0.2964     | 0.2964     |   0.0 |  0.38
Other   |            | 0.04354    |            |       |  0.06

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

Total # of neighbors = 311028
Ave neighs/atom = 77.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.569901085637, Press = -3.05497782048786
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13852.529   -13852.529    -14006.31    -14006.31    297.49932    297.49932    48110.416    48110.416    79.910053    79.910053 
   16000    -13857.92    -13857.92   -14008.496   -14008.496    291.29919    291.29919    48142.648    48142.648   -1111.3729   -1111.3729 
Loop time of 78.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.878 hours/ns, 12.696 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    | 78.376     | 78.376     | 78.376     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04741    | 0.04741    | 0.04741    |   0.0 |  0.06
Output  | 0.00010402 | 0.00010402 | 0.00010402 |   0.0 |  0.00
Modify  | 0.29525    | 0.29525    | 0.29525    |   0.0 |  0.37
Other   |            | 0.04319    |            |       |  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:      310974.0 ave      310974 max      310974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310974
Ave neighs/atom = 77.743500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.451862783202, Press = 1.80894924120875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13857.92    -13857.92   -14008.496   -14008.496    291.29919    291.29919    48142.648    48142.648   -1111.3729   -1111.3729 
   17000   -13852.673   -13852.673    -14006.35    -14006.35    297.29829    297.29829     48054.74     48054.74    1729.7564    1729.7564 
Loop time of 78.7278 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.869 hours/ns, 12.702 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    | 78.342     | 78.342     | 78.342     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047217   | 0.047217   | 0.047217   |   0.0 |  0.06
Output  | 0.00010351 | 0.00010351 | 0.00010351 |   0.0 |  0.00
Modify  | 0.29514    | 0.29514    | 0.29514    |   0.0 |  0.37
Other   |            | 0.04341    |            |       |  0.06

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

Total # of neighbors = 310958
Ave neighs/atom = 77.739500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.427608555028, Press = -0.796535856710868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13852.673   -13852.673    -14006.35    -14006.35    297.29829    297.29829     48054.74     48054.74    1729.7564    1729.7564 
   18000   -13856.476   -13856.476   -14007.805   -14007.805    292.75597    292.75597    48181.497    48181.497   -2087.8682   -2087.8682 
Loop time of 78.8123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.096 ns/day, 21.892 hours/ns, 12.688 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    | 78.426     | 78.426     | 78.426     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047603   | 0.047603   | 0.047603   |   0.0 |  0.06
Output  | 0.00010429 | 0.00010429 | 0.00010429 |   0.0 |  0.00
Modify  | 0.2954     | 0.2954     | 0.2954     |   0.0 |  0.37
Other   |            | 0.04326    |            |       |  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:      311024.0 ave      311024 max      311024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311024
Ave neighs/atom = 77.756000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.421317230637, Press = -1.76261468613322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.476   -13856.476   -14007.805   -14007.805    292.75597    292.75597    48181.497    48181.497   -2087.8682   -2087.8682 
   19000   -13856.285   -13856.285   -14008.319   -14008.319      294.121      294.121    48073.326    48073.326    1029.1672    1029.1672 
Loop time of 79.0116 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.094 ns/day, 21.948 hours/ns, 12.656 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    | 78.623     | 78.623     | 78.623     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047422   | 0.047422   | 0.047422   |   0.0 |  0.06
Output  | 0.00010391 | 0.00010391 | 0.00010391 |   0.0 |  0.00
Modify  | 0.29683    | 0.29683    | 0.29683    |   0.0 |  0.38
Other   |            | 0.04375    |            |       |  0.06

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

Total # of neighbors = 310864
Ave neighs/atom = 77.716000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.479686865559, Press = 1.38005768659277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.285   -13856.285   -14008.319   -14008.319      294.121      294.121    48073.326    48073.326    1029.1672    1029.1672 
   20000   -13854.328   -13854.328   -14004.408   -14004.408    290.34008    290.34008    48110.343    48110.343    211.65349    211.65349 
Loop time of 78.8977 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.916 hours/ns, 12.675 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    | 78.511     | 78.511     | 78.511     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047335   | 0.047335   | 0.047335   |   0.0 |  0.06
Output  | 0.00010537 | 0.00010537 | 0.00010537 |   0.0 |  0.00
Modify  | 0.29568    | 0.29568    | 0.29568    |   0.0 |  0.37
Other   |            | 0.04317    |            |       |  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:      311076.0 ave      311076 max      311076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311076
Ave neighs/atom = 77.769000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.442408755526, Press = -1.75282463258937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.328   -13854.328   -14004.408   -14004.408    290.34008    290.34008    48110.343    48110.343    211.65349    211.65349 
   21000   -13858.277   -13858.277   -14004.775   -14004.775    283.40991    283.40991    48110.601    48110.601    83.345893    83.345893 
Loop time of 78.9028 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.917 hours/ns, 12.674 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    | 78.515     | 78.515     | 78.515     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047792   | 0.047792   | 0.047792   |   0.0 |  0.06
Output  | 0.00010603 | 0.00010603 | 0.00010603 |   0.0 |  0.00
Modify  | 0.29648    | 0.29648    | 0.29648    |   0.0 |  0.38
Other   |            | 0.04343    |            |       |  0.06

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

Total # of neighbors = 310972
Ave neighs/atom = 77.743000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.54194859302, Press = 0.401639200067624
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.277   -13858.277   -14004.775   -14004.775    283.40991    283.40991    48110.601    48110.601    83.345893    83.345893 
   22000   -13849.841   -13849.841   -14004.947   -14004.947    300.06169    300.06169    48090.636    48090.636    854.73479    854.73479 
Loop time of 78.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.927 hours/ns, 12.668 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    | 78.552     | 78.552     | 78.552     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047744   | 0.047744   | 0.047744   |   0.0 |  0.06
Output  | 0.0001015  | 0.0001015  | 0.0001015  |   0.0 |  0.00
Modify  | 0.29618    | 0.29618    | 0.29618    |   0.0 |  0.38
Other   |            | 0.04339    |            |       |  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:      310958.0 ave      310958 max      310958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310958
Ave neighs/atom = 77.739500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.543559230529, Press = -1.11278829635078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13849.841   -13849.841   -14004.947   -14004.947    300.06169    300.06169    48090.636    48090.636    854.73479    854.73479 
   23000    -13855.49    -13855.49   -14006.562   -14006.562    292.26009    292.26009    48222.849    48222.849   -3199.3619   -3199.3619 
Loop time of 78.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.926 hours/ns, 12.669 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    | 78.546     | 78.546     | 78.546     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047765   | 0.047765   | 0.047765   |   0.0 |  0.06
Output  | 0.00010548 | 0.00010548 | 0.00010548 |   0.0 |  0.00
Modify  | 0.2961     | 0.2961     | 0.2961     |   0.0 |  0.38
Other   |            | 0.04344    |            |       |  0.06

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

Total # of neighbors = 310868
Ave neighs/atom = 77.717000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.564013808941, Press = 1.39742936906378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13855.49    -13855.49   -14006.562   -14006.562    292.26009    292.26009    48222.849    48222.849   -3199.3619   -3199.3619 
   24000   -13853.071   -13853.071   -14007.158   -14007.158    298.09275    298.09275    48043.244    48043.244    2029.3241    2029.3241 
Loop time of 78.8103 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.096 ns/day, 21.892 hours/ns, 12.689 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    | 78.424     | 78.424     | 78.424     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047419   | 0.047419   | 0.047419   |   0.0 |  0.06
Output  | 0.00010319 | 0.00010319 | 0.00010319 |   0.0 |  0.00
Modify  | 0.29557    | 0.29557    | 0.29557    |   0.0 |  0.38
Other   |            | 0.04328    |            |       |  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:      310928.0 ave      310928 max      310928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310928
Ave neighs/atom = 77.732000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.592072226614, Press = 0.0647116469229598
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.071   -13853.071   -14007.158   -14007.158    298.09275    298.09275    48043.244    48043.244    2029.3241    2029.3241 
   25000   -13858.283   -13858.283   -14009.188   -14009.188    291.93572    291.93572    48149.099    48149.099   -1308.3718   -1308.3718 
Loop time of 78.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.096 ns/day, 21.897 hours/ns, 12.686 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    | 78.443     | 78.443     | 78.443     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047698   | 0.047698   | 0.047698   |   0.0 |  0.06
Output  | 0.00010325 | 0.00010325 | 0.00010325 |   0.0 |  0.00
Modify  | 0.29572    | 0.29572    | 0.29572    |   0.0 |  0.38
Other   |            | 0.04341    |            |       |  0.06

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

Total # of neighbors = 310998
Ave neighs/atom = 77.749500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.529610437845, Press = -1.15315057683663
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.283   -13858.283   -14009.188   -14009.188    291.93572    291.93572    48149.099    48149.099   -1308.3718   -1308.3718 
   26000    -13851.46    -13851.46   -14005.387   -14005.387    297.78119    297.78119    48098.631    48098.631    527.51228    527.51228 
Loop time of 78.7246 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.868 hours/ns, 12.703 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    | 78.341     | 78.341     | 78.341     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04726    | 0.04726    | 0.04726    |   0.0 |  0.06
Output  | 0.00010489 | 0.00010489 | 0.00010489 |   0.0 |  0.00
Modify  | 0.29377    | 0.29377    | 0.29377    |   0.0 |  0.37
Other   |            | 0.04256    |            |       |  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:      311030.0 ave      311030 max      311030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311030
Ave neighs/atom = 77.757500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.505134843829, Press = 0.851845035131914
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13851.46    -13851.46   -14005.387   -14005.387    297.78119    297.78119    48098.631    48098.631    527.51228    527.51228 
   27000   -13858.701   -13858.701   -14009.071   -14009.071    290.90101    290.90101    48110.426    48110.426   -234.74138   -234.74138 
Loop time of 78.7399 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.872 hours/ns, 12.700 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    | 78.357     | 78.357     | 78.357     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047085   | 0.047085   | 0.047085   |   0.0 |  0.06
Output  | 9.916e-05  | 9.916e-05  | 9.916e-05  |   0.0 |  0.00
Modify  | 0.29341    | 0.29341    | 0.29341    |   0.0 |  0.37
Other   |            | 0.04248    |            |       |  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:      310998.0 ave      310998 max      310998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310998
Ave neighs/atom = 77.749500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.488710593113, Press = -1.72458738955686
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.701   -13858.701   -14009.071   -14009.071    290.90101    290.90101    48110.426    48110.426   -234.74138   -234.74138 
   28000   -13855.759   -13855.759    -14006.81    -14006.81    292.21915    292.21915    48122.373    48122.373   -278.88415   -278.88415 
Loop time of 78.6394 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.844 hours/ns, 12.716 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    | 78.254     | 78.254     | 78.254     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047327   | 0.047327   | 0.047327   |   0.0 |  0.06
Output  | 0.00010392 | 0.00010392 | 0.00010392 |   0.0 |  0.00
Modify  | 0.29443    | 0.29443    | 0.29443    |   0.0 |  0.37
Other   |            | 0.04312    |            |       |  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:      311054.0 ave      311054 max      311054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311054
Ave neighs/atom = 77.763500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.507250987919, Press = 1.62240128086941
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.759   -13855.759    -14006.81    -14006.81    292.21915    292.21915    48122.373    48122.373   -278.88415   -278.88415 
   29000   -13849.173   -13849.173    -14002.64    -14002.64    296.89284    296.89284    48051.161    48051.161    2235.2249    2235.2249 
Loop time of 78.5757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.827 hours/ns, 12.727 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    | 78.193     | 78.193     | 78.193     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046935   | 0.046935   | 0.046935   |   0.0 |  0.06
Output  | 0.00010256 | 0.00010256 | 0.00010256 |   0.0 |  0.00
Modify  | 0.29361    | 0.29361    | 0.29361    |   0.0 |  0.37
Other   |            | 0.04243    |            |       |  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:      311044.0 ave      311044 max      311044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311044
Ave neighs/atom = 77.761000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.523620150846, Press = -2.20569109637339
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13849.173   -13849.173    -14002.64    -14002.64    296.89284    296.89284    48051.161    48051.161    2235.2249    2235.2249 
   30000   -13855.317   -13855.317   -14005.511   -14005.511    290.55989    290.55989    48170.444    48170.444    -1702.768    -1702.768 
Loop time of 78.5283 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.813 hours/ns, 12.734 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    | 78.146     | 78.146     | 78.146     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046979   | 0.046979   | 0.046979   |   0.0 |  0.06
Output  | 9.9858e-05 | 9.9858e-05 | 9.9858e-05 |   0.0 |  0.00
Modify  | 0.29297    | 0.29297    | 0.29297    |   0.0 |  0.37
Other   |            | 0.04248    |            |       |  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:      311010.0 ave      311010 max      311010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311010
Ave neighs/atom = 77.752500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.540374769977, Press = 0.285927706194222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.317   -13855.317   -14005.511   -14005.511    290.55989    290.55989    48170.444    48170.444    -1702.768    -1702.768 
   31000   -13849.365   -13849.365   -14003.365   -14003.365    297.92447    297.92447    48077.862    48077.862    1364.1625    1364.1625 
Loop time of 78.6624 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.098 ns/day, 21.851 hours/ns, 12.713 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    | 78.279     | 78.279     | 78.279     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047295   | 0.047295   | 0.047295   |   0.0 |  0.06
Output  | 0.0001023  | 0.0001023  | 0.0001023  |   0.0 |  0.00
Modify  | 0.2934     | 0.2934     | 0.2934     |   0.0 |  0.37
Other   |            | 0.0424     |            |       |  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:      310888.0 ave      310888 max      310888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310888
Ave neighs/atom = 77.722000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.625466283968, Press = 0.159069556775401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13849.365   -13849.365   -14003.365   -14003.365    297.92447    297.92447    48077.862    48077.862    1364.1625    1364.1625 
   32000   -13854.189   -13854.189   -14007.537   -14007.537    296.66289    296.66289    48155.968    48155.968   -1360.9301   -1360.9301 
Loop time of 78.6448 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.846 hours/ns, 12.715 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    | 78.261     | 78.261     | 78.261     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046933   | 0.046933   | 0.046933   |   0.0 |  0.06
Output  | 0.000101   | 0.000101   | 0.000101   |   0.0 |  0.00
Modify  | 0.29388    | 0.29388    | 0.29388    |   0.0 |  0.37
Other   |            | 0.04268    |            |       |  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:      310922.0 ave      310922 max      310922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310922
Ave neighs/atom = 77.730500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.610497318976, Press = -0.715598980168454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.189   -13854.189   -14007.537   -14007.537    296.66289    296.66289    48155.968    48155.968   -1360.9301   -1360.9301 
   33000   -13858.357   -13858.357   -14010.319   -14010.319    293.98107    293.98107    48082.026    48082.026    490.30307    490.30307 
Loop time of 78.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.842 hours/ns, 12.718 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    | 78.246     | 78.246     | 78.246     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04709    | 0.04709    | 0.04709    |   0.0 |  0.06
Output  | 0.00010539 | 0.00010539 | 0.00010539 |   0.0 |  0.00
Modify  | 0.29376    | 0.29376    | 0.29376    |   0.0 |  0.37
Other   |            | 0.04261    |            |       |  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:      310952.0 ave      310952 max      310952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310952
Ave neighs/atom = 77.738000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.575984422179, Press = 1.11819831221302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13858.357   -13858.357   -14010.319   -14010.319    293.98107    293.98107    48082.026    48082.026    490.30307    490.30307 
   34000   -13856.099   -13856.099   -14010.213   -14010.213    298.14559    298.14559    48116.497    48116.497   -417.75124   -417.75124 
Loop time of 78.5664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.824 hours/ns, 12.728 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    | 78.182     | 78.182     | 78.182     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04753    | 0.04753    | 0.04753    |   0.0 |  0.06
Output  | 0.00010347 | 0.00010347 | 0.00010347 |   0.0 |  0.00
Modify  | 0.29389    | 0.29389    | 0.29389    |   0.0 |  0.37
Other   |            | 0.04275    |            |       |  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:      311030.0 ave      311030 max      311030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311030
Ave neighs/atom = 77.757500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.533013203657, Press = -1.77954127070025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13856.099   -13856.099   -14010.213   -14010.213    298.14559    298.14559    48116.497    48116.497   -417.75124   -417.75124 
   35000   -13855.406   -13855.406   -14006.658   -14006.658    292.60684    292.60684     48134.52     48134.52    -642.0918    -642.0918 
Loop time of 78.5746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.826 hours/ns, 12.727 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    | 78.191     | 78.191     | 78.191     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047022   | 0.047022   | 0.047022   |   0.0 |  0.06
Output  | 0.00010015 | 0.00010015 | 0.00010015 |   0.0 |  0.00
Modify  | 0.2939     | 0.2939     | 0.2939     |   0.0 |  0.37
Other   |            | 0.0429     |            |       |  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:      311098.0 ave      311098 max      311098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311098
Ave neighs/atom = 77.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544785249255, Press = 2.93254454741977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13855.406   -13855.406   -14006.658   -14006.658    292.60684    292.60684     48134.52     48134.52    -642.0918    -642.0918 
   36000   -13857.359   -13857.359   -14006.481   -14006.481    288.48683    288.48683    48076.039    48076.039    971.06428    971.06428 
Loop time of 78.6366 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.843 hours/ns, 12.717 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    | 78.252     | 78.252     | 78.252     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047087   | 0.047087   | 0.047087   |   0.0 |  0.06
Output  | 0.00010257 | 0.00010257 | 0.00010257 |   0.0 |  0.00
Modify  | 0.29425    | 0.29425    | 0.29425    |   0.0 |  0.37
Other   |            | 0.04298    |            |       |  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:      310882.0 ave      310882 max      310882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310882
Ave neighs/atom = 77.720500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.449192430161, Press = -0.764929902252671
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13857.359   -13857.359   -14006.481   -14006.481    288.48683    288.48683    48076.039    48076.039    971.06428    971.06428 
   37000    -13853.42    -13853.42   -14005.031   -14005.031    293.30237    293.30237    48136.372    48136.372   -543.00878   -543.00878 
Loop time of 78.6003 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.833 hours/ns, 12.723 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    | 78.216     | 78.216     | 78.216     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046934   | 0.046934   | 0.046934   |   0.0 |  0.06
Output  | 0.00010243 | 0.00010243 | 0.00010243 |   0.0 |  0.00
Modify  | 0.2936     | 0.2936     | 0.2936     |   0.0 |  0.37
Other   |            | 0.04345    |            |       |  0.06

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

Total # of neighbors = 310928
Ave neighs/atom = 77.732000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441838551247, Press = 0.526763891351179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13853.42    -13853.42   -14005.031   -14005.031    293.30237    293.30237    48136.372    48136.372   -543.00878   -543.00878 
   38000   -13854.636   -13854.636   -14007.902   -14007.902    296.50284    296.50284    48087.691    48087.691    604.94165    604.94165 
Loop time of 78.6271 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.841 hours/ns, 12.718 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    | 78.243     | 78.243     | 78.243     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046946   | 0.046946   | 0.046946   |   0.0 |  0.06
Output  | 0.00010424 | 0.00010424 | 0.00010424 |   0.0 |  0.00
Modify  | 0.29392    | 0.29392    | 0.29392    |   0.0 |  0.37
Other   |            | 0.04296    |            |       |  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:      310874.0 ave      310874 max      310874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310874
Ave neighs/atom = 77.718500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42596620158, Press = -0.372716381537903
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.636   -13854.636   -14007.902   -14007.902    296.50284    296.50284    48087.691    48087.691    604.94165    604.94165 
   39000    -13859.76    -13859.76   -14007.631   -14007.631    286.06703    286.06703    48190.319    48190.319     -2373.44     -2373.44 
Loop time of 78.2842 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.104 ns/day, 21.746 hours/ns, 12.774 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    | 77.906     | 77.906     | 77.906     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0464     | 0.0464     | 0.0464     |   0.0 |  0.06
Output  | 0.00010275 | 0.00010275 | 0.00010275 |   0.0 |  0.00
Modify  | 0.29004    | 0.29004    | 0.29004    |   0.0 |  0.37
Other   |            | 0.04131    |            |       |  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:      311038.0 ave      311038 max      311038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311038
Ave neighs/atom = 77.759500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.384944395929, Press = 0.748718939721989
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -13859.76    -13859.76   -14007.631   -14007.631    286.06703    286.06703    48190.319    48190.319     -2373.44     -2373.44 
   40000   -13854.885   -13854.885    -14009.24    -14009.24    298.61072    298.61072    48003.592    48003.592    2999.5593    2999.5593 
Loop time of 78.4462 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.101 ns/day, 21.791 hours/ns, 12.748 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    | 78.069     | 78.069     | 78.069     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046461   | 0.046461   | 0.046461   |   0.0 |  0.06
Output  | 0.00010123 | 0.00010123 | 0.00010123 |   0.0 |  0.00
Modify  | 0.2898     | 0.2898     | 0.2898     |   0.0 |  0.37
Other   |            | 0.04123    |            |       |  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:      310924.0 ave      310924 max      310924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310924
Ave neighs/atom = 77.731000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38323630188, Press = 0.115637787160412
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13854.885   -13854.885    -14009.24    -14009.24    298.61072    298.61072    48003.592    48003.592    2999.5593    2999.5593 
   41000   -13859.309   -13859.309   -14011.861   -14011.861    295.12045    295.12045    48159.317    48159.317   -1801.5824   -1801.5824 
Loop time of 78.5464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.818 hours/ns, 12.731 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    | 78.16      | 78.16      | 78.16      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046755   | 0.046755   | 0.046755   |   0.0 |  0.06
Output  | 0.00010271 | 0.00010271 | 0.00010271 |   0.0 |  0.00
Modify  | 0.29407    | 0.29407    | 0.29407    |   0.0 |  0.37
Other   |            | 0.0456     |            |       |  0.06

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

Total # of neighbors = 311144
Ave neighs/atom = 77.786000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.381557993758, Press = -0.266252494200642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.309   -13859.309   -14011.861   -14011.861    295.12045    295.12045    48159.317    48159.317   -1801.5824   -1801.5824 
   42000   -13853.422   -13853.422   -14006.374   -14006.374    295.89507    295.89507    48088.608    48088.608    720.82192    720.82192 
Loop time of 78.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.101 ns/day, 21.789 hours/ns, 12.748 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    | 78.063     | 78.063     | 78.063     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046601   | 0.046601   | 0.046601   |   0.0 |  0.06
Output  | 0.00010214 | 0.00010214 | 0.00010214 |   0.0 |  0.00
Modify  | 0.29008    | 0.29008    | 0.29008    |   0.0 |  0.37
Other   |            | 0.04123    |            |       |  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:      311128.0 ave      311128 max      311128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311128
Ave neighs/atom = 77.782000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.339147212991, Press = 1.38632960912456
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13853.422   -13853.422   -14006.374   -14006.374    295.89507    295.89507    48088.608    48088.608    720.82192    720.82192 
   43000   -13859.282   -13859.282   -14009.514   -14009.514    290.63431    290.63431    48088.693    48088.693    272.79953    272.79953 
Loop time of 78.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.103 ns/day, 21.751 hours/ns, 12.771 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    | 77.927     | 77.927     | 77.927     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046624   | 0.046624   | 0.046624   |   0.0 |  0.06
Output  | 0.00010266 | 0.00010266 | 0.00010266 |   0.0 |  0.00
Modify  | 0.28941    | 0.28941    | 0.28941    |   0.0 |  0.37
Other   |            | 0.04088    |            |       |  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:      310794.0 ave      310794 max      310794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310794
Ave neighs/atom = 77.698500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.292841415554, Press = -0.285077816826999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -13859.282   -13859.282   -14009.514   -14009.514    290.63431    290.63431    48088.693    48088.693    272.79953    272.79953 
   44000   -13855.278   -13855.278   -14006.513   -14006.513    292.57356    292.57356    48120.038    48120.038   -262.77353   -262.77353 
Loop time of 78.3644 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.103 ns/day, 21.768 hours/ns, 12.761 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    | 77.988     | 77.988     | 77.988     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046504   | 0.046504   | 0.046504   |   0.0 |  0.06
Output  | 0.00010178 | 0.00010178 | 0.00010178 |   0.0 |  0.00
Modify  | 0.28926    | 0.28926    | 0.28926    |   0.0 |  0.37
Other   |            | 0.04083    |            |       |  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:      310976.0 ave      310976 max      310976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310976
Ave neighs/atom = 77.744000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
48112.3012959291

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0