# 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.565626531839371*${_u_distance}
variable latticeconst_converted equal 3.565626531839371*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  3.56562653183937
Lattice spacing in x,y,z = 3.5656265 3.5656265 3.5656265
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 (35.656265 35.656265 35.656265)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.656265 35.656265 35.656265)
  create_atoms CPU = 0.003 seconds

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

kim_interactions C

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

kim interactions C
#=== BEGIN kim interactions ==================================
pair_style kim Tersoff_LAMMPS_Tersoff_1989_SiC__MO_171585019474_004
pair_coeff * * C
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 12.0107

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -58681.69    -58681.69   -58964.114   -58964.114       273.15       273.15     45332.28     45332.28     6654.542     6654.542 
    1000   -58373.348   -58373.348   -58664.896   -58664.896    281.97472    281.97472    45519.143    45519.143    3470.5196    3470.5196 
Loop time of 88.4121 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.977 ns/day, 24.559 hours/ns, 11.311 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    | 87.679     | 87.679     | 87.679     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074411   | 0.074411   | 0.074411   |   0.0 |  0.08
Output  | 0.0002663  | 0.0002663  | 0.0002663  |   0.0 |  0.00
Modify  | 0.58092    | 0.58092    | 0.58092    |   0.0 |  0.66
Other   |            | 0.07759    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      688000.0 ave      688000 max      688000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 688000
Ave neighs/atom = 86.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -58373.348   -58373.348   -58664.896   -58664.896    281.97472    281.97472    45519.143    45519.143    3470.5196    3470.5196 
    2000   -58402.314   -58402.314   -58678.854   -58678.854    267.45988    267.45988    45525.443    45525.443    1781.1586    1781.1586 
Loop time of 85.7966 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.007 ns/day, 23.832 hours/ns, 11.655 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    | 85.098     | 85.098     | 85.098     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071986   | 0.071986   | 0.071986   |   0.0 |  0.08
Output  | 0.00015773 | 0.00015773 | 0.00015773 |   0.0 |  0.00
Modify  | 0.55632    | 0.55632    | 0.55632    |   0.0 |  0.65
Other   |            | 0.07068    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695520.0 ave      695520 max      695520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695520
Ave neighs/atom = 86.940000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -58402.314   -58402.314   -58678.854   -58678.854    267.45988    267.45988    45525.443    45525.443    1781.1586    1781.1586 
    3000   -58390.533   -58390.533   -58671.113   -58671.113    271.36696    271.36696    45538.909    45538.909    704.69406    704.69406 
Loop time of 85.9934 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.005 ns/day, 23.887 hours/ns, 11.629 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    | 85.292     | 85.292     | 85.292     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071886   | 0.071886   | 0.071886   |   0.0 |  0.08
Output  | 0.00017115 | 0.00017115 | 0.00017115 |   0.0 |  0.00
Modify  | 0.55718    | 0.55718    | 0.55718    |   0.0 |  0.65
Other   |            | 0.07172    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695142.0 ave      695142 max      695142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695142
Ave neighs/atom = 86.892750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -58390.533   -58390.533   -58671.113   -58671.113    271.36696    271.36696    45538.909    45538.909    704.69406    704.69406 
    4000   -58392.754   -58392.754   -58681.463   -58681.463    279.22917    279.22917    45543.394    45543.394    120.65746    120.65746 
Loop time of 85.8718 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.006 ns/day, 23.853 hours/ns, 11.645 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    | 85.173     | 85.173     | 85.173     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071802   | 0.071802   | 0.071802   |   0.0 |  0.08
Output  | 0.00016392 | 0.00016392 | 0.00016392 |   0.0 |  0.00
Modify  | 0.55588    | 0.55588    | 0.55588    |   0.0 |  0.65
Other   |            | 0.07107    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695566.0 ave      695566 max      695566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695566
Ave neighs/atom = 86.945750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -58392.754   -58392.754   -58681.463   -58681.463    279.22917    279.22917    45543.394    45543.394    120.65746    120.65746 
    5000   -58397.523   -58397.523    -58681.65    -58681.65    274.79712    274.79712    45548.535    45548.535   -381.52194   -381.52194 
Loop time of 85.8818 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.006 ns/day, 23.856 hours/ns, 11.644 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    | 85.181     | 85.181     | 85.181     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072177   | 0.072177   | 0.072177   |   0.0 |  0.08
Output  | 0.0001415  | 0.0001415  | 0.0001415  |   0.0 |  0.00
Modify  | 0.55758    | 0.55758    | 0.55758    |   0.0 |  0.65
Other   |            | 0.07128    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695028.0 ave      695028 max      695028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695028
Ave neighs/atom = 86.878500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.535612795339, Press = -681.138914139938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -58397.523   -58397.523    -58681.65    -58681.65    274.79712    274.79712    45548.535    45548.535   -381.52194   -381.52194 
    6000   -58388.414   -58388.414   -58673.676   -58673.676    275.89507    275.89507    45572.005    45572.005   -2140.8562   -2140.8562 
Loop time of 92.1087 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.938 ns/day, 25.586 hours/ns, 10.857 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    | 91.327     | 91.327     | 91.327     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076855   | 0.076855   | 0.076855   |   0.0 |  0.08
Output  | 0.00013806 | 0.00013806 | 0.00013806 |   0.0 |  0.00
Modify  | 0.62008    | 0.62008    | 0.62008    |   0.0 |  0.67
Other   |            | 0.08481    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694950.0 ave      694950 max      694950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694950
Ave neighs/atom = 86.868750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.817793154313, Press = -92.7569410714771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -58388.414   -58388.414   -58673.676   -58673.676    275.89507    275.89507    45572.005    45572.005   -2140.8562   -2140.8562 
    7000   -58398.621   -58398.621   -58680.583   -58680.583    272.70394    272.70394    45573.357    45573.357   -2605.1552   -2605.1552 
Loop time of 95.4576 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.905 ns/day, 26.516 hours/ns, 10.476 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    | 94.641     | 94.641     | 94.641     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078742   | 0.078742   | 0.078742   |   0.0 |  0.08
Output  | 0.0002406  | 0.0002406  | 0.0002406  |   0.0 |  0.00
Modify  | 0.64607    | 0.64607    | 0.64607    |   0.0 |  0.68
Other   |            | 0.09193    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694510.0 ave      694510 max      694510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694510
Ave neighs/atom = 86.813750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.004899423597, Press = -36.3887274595673
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -58398.621   -58398.621   -58680.583   -58680.583    272.70394    272.70394    45573.357    45573.357   -2605.1552   -2605.1552 
    8000   -58389.989   -58389.989   -58671.305   -58671.305    272.07853    272.07853    45568.561    45568.561   -1670.2733   -1670.2733 
Loop time of 92.1869 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.937 ns/day, 25.607 hours/ns, 10.848 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    | 91.405     | 91.405     | 91.405     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076577   | 0.076577   | 0.076577   |   0.0 |  0.08
Output  | 0.00016853 | 0.00016853 | 0.00016853 |   0.0 |  0.00
Modify  | 0.61998    | 0.61998    | 0.61998    |   0.0 |  0.67
Other   |            | 0.08526    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694110.0 ave      694110 max      694110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694110
Ave neighs/atom = 86.763750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.104643116584, Press = -11.1088873026066
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -58389.989   -58389.989   -58671.305   -58671.305    272.07853    272.07853    45568.561    45568.561   -1670.2733   -1670.2733 
    9000   -58395.012   -58395.012    -58676.61    -58676.61    272.35112    272.35112     45559.83     45559.83   -1188.7464   -1188.7464 
Loop time of 91.6032 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.943 ns/day, 25.445 hours/ns, 10.917 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    | 90.827     | 90.827     | 90.827     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076471   | 0.076471   | 0.076471   |   0.0 |  0.08
Output  | 0.00024494 | 0.00024494 | 0.00024494 |   0.0 |  0.00
Modify  | 0.6153     | 0.6153     | 0.6153     |   0.0 |  0.67
Other   |            | 0.08453    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694820.0 ave      694820 max      694820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694820
Ave neighs/atom = 86.852500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.032921645199, Press = -3.330054420327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -58395.012   -58395.012    -58676.61    -58676.61    272.35112    272.35112     45559.83     45559.83   -1188.7464   -1188.7464 
   10000    -58396.45    -58396.45   -58677.025   -58677.025    271.36097    271.36097    45559.451    45559.451   -1286.1453   -1286.1453 
Loop time of 88.2114 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.979 ns/day, 24.503 hours/ns, 11.336 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    | 87.459     | 87.459     | 87.459     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074743   | 0.074743   | 0.074743   |   0.0 |  0.08
Output  | 0.00013193 | 0.00013193 | 0.00013193 |   0.0 |  0.00
Modify  | 0.59606    | 0.59606    | 0.59606    |   0.0 |  0.68
Other   |            | 0.08192    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694414.0 ave      694414 max      694414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694414
Ave neighs/atom = 86.801750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.124877739359, Press = -1.06647914693365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -58396.45    -58396.45   -58677.025   -58677.025    271.36097    271.36097    45559.451    45559.451   -1286.1453   -1286.1453 
   11000   -58390.248   -58390.248    -58675.05    -58675.05     275.4493     275.4493    45560.506    45560.506   -1026.3809   -1026.3809 
Loop time of 84.4389 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.023 ns/day, 23.455 hours/ns, 11.843 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    | 83.732     | 83.732     | 83.732     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070904   | 0.070904   | 0.070904   |   0.0 |  0.08
Output  | 0.00015407 | 0.00015407 | 0.00015407 |   0.0 |  0.00
Modify  | 0.56048    | 0.56048    | 0.56048    |   0.0 |  0.66
Other   |            | 0.0749     |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694590.0 ave      694590 max      694590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694590
Ave neighs/atom = 86.823750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.006936266913, Press = 2.30318672653735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -58390.248   -58390.248    -58675.05    -58675.05     275.4493     275.4493    45560.506    45560.506   -1026.3809   -1026.3809 
   12000   -58398.808   -58398.808   -58678.772   -58678.772    270.77119    270.77119    45555.887    45555.887   -881.24137   -881.24137 
Loop time of 84.5178 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.022 ns/day, 23.477 hours/ns, 11.832 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    | 83.812     | 83.812     | 83.812     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071592   | 0.071592   | 0.071592   |   0.0 |  0.08
Output  | 0.00013479 | 0.00013479 | 0.00013479 |   0.0 |  0.00
Modify  | 0.56019    | 0.56019    | 0.56019    |   0.0 |  0.66
Other   |            | 0.07433    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694698.0 ave      694698 max      694698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694698
Ave neighs/atom = 86.837250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.988847815061, Press = 7.02795949657181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -58398.808   -58398.808   -58678.772   -58678.772    270.77119    270.77119    45555.887    45555.887   -881.24137   -881.24137 
   13000   -58392.096   -58392.096   -58670.272   -58670.272    269.04179    269.04179    45547.674    45547.674    136.44615    136.44615 
Loop time of 84.353 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.024 ns/day, 23.431 hours/ns, 11.855 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    | 83.652     | 83.652     | 83.652     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070813   | 0.070813   | 0.070813   |   0.0 |  0.08
Output  | 0.00012913 | 0.00012913 | 0.00012913 |   0.0 |  0.00
Modify  | 0.55911    | 0.55911    | 0.55911    |   0.0 |  0.66
Other   |            | 0.07133    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694498.0 ave      694498 max      694498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694498
Ave neighs/atom = 86.812250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.89058885658, Press = 10.3505369028782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -58392.096   -58392.096   -58670.272   -58670.272    269.04179    269.04179    45547.674    45547.674    136.44615    136.44615 
   14000   -58401.667   -58401.667   -58680.337   -58680.337    269.51882    269.51882    45536.585    45536.585    566.88423    566.88423 
Loop time of 84.2423 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.026 ns/day, 23.401 hours/ns, 11.871 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    | 83.533     | 83.533     | 83.533     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070956   | 0.070956   | 0.070956   |   0.0 |  0.08
Output  | 0.00014134 | 0.00014134 | 0.00014134 |   0.0 |  0.00
Modify  | 0.56294    | 0.56294    | 0.56294    |   0.0 |  0.67
Other   |            | 0.07486    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695054.0 ave      695054 max      695054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695054
Ave neighs/atom = 86.881750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.83673773293, Press = 4.7324801987838
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -58401.667   -58401.667   -58680.337   -58680.337    269.51882    269.51882    45536.585    45536.585    566.88423    566.88423 
   15000   -58393.246   -58393.246   -58679.636   -58679.636    276.98518    276.98518    45539.009    45539.009    613.53795    613.53795 
Loop time of 84.2503 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.026 ns/day, 23.403 hours/ns, 11.869 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    | 83.54      | 83.54      | 83.54      |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071198   | 0.071198   | 0.071198   |   0.0 |  0.08
Output  | 0.00015172 | 0.00015172 | 0.00015172 |   0.0 |  0.00
Modify  | 0.56429    | 0.56429    | 0.56429    |   0.0 |  0.67
Other   |            | 0.07486    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694878.0 ave      694878 max      694878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694878
Ave neighs/atom = 86.859750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.795141256433, Press = 0.667451531079644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -58393.246   -58393.246   -58679.636   -58679.636    276.98518    276.98518    45539.009    45539.009    613.53795    613.53795 
   16000   -58395.214   -58395.214   -58677.294   -58677.294    272.81655    272.81655    45538.015    45538.015    835.61172    835.61172 
Loop time of 84.4493 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.023 ns/day, 23.458 hours/ns, 11.841 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    | 83.725     | 83.725     | 83.725     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071818   | 0.071818   | 0.071818   |   0.0 |  0.09
Output  | 0.00013045 | 0.00013045 | 0.00013045 |   0.0 |  0.00
Modify  | 0.57166    | 0.57166    | 0.57166    |   0.0 |  0.68
Other   |            | 0.08045    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695108.0 ave      695108 max      695108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695108
Ave neighs/atom = 86.888500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.801442291867, Press = 0.310205078402241
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -58395.214   -58395.214   -58677.294   -58677.294    272.81655    272.81655    45538.015    45538.015    835.61172    835.61172 
   17000   -58395.508   -58395.508   -58677.479   -58677.479    272.71109    272.71109    45532.434    45532.434    1237.2867    1237.2867 
Loop time of 84.7147 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.020 ns/day, 23.532 hours/ns, 11.804 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    | 83.972     | 83.972     | 83.972     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074016   | 0.074016   | 0.074016   |   0.0 |  0.09
Output  | 0.0001322  | 0.0001322  | 0.0001322  |   0.0 |  0.00
Modify  | 0.58061    | 0.58061    | 0.58061    |   0.0 |  0.69
Other   |            | 0.08749    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695016.0 ave      695016 max      695016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695016
Ave neighs/atom = 86.877000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.826096779884, Press = -0.507748401684001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -58395.508   -58395.508   -58677.479   -58677.479    272.71109    272.71109    45532.434    45532.434    1237.2867    1237.2867 
   18000   -58392.147   -58392.147   -58677.441   -58677.441    275.92499    275.92499    45525.158    45525.158    2036.7946    2036.7946 
Loop time of 84.5992 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.021 ns/day, 23.500 hours/ns, 11.820 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    | 83.855     | 83.855     | 83.855     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07405    | 0.07405    | 0.07405    |   0.0 |  0.09
Output  | 0.00025533 | 0.00025533 | 0.00025533 |   0.0 |  0.00
Modify  | 0.58125    | 0.58125    | 0.58125    |   0.0 |  0.69
Other   |            | 0.08835    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695222.0 ave      695222 max      695222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695222
Ave neighs/atom = 86.902750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.742390577354, Press = -1.11086560786168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -58392.147   -58392.147   -58677.441   -58677.441    275.92499    275.92499    45525.158    45525.158    2036.7946    2036.7946 
   19000   -58398.167   -58398.167   -58680.801   -58680.801    273.35271    273.35271    45520.145    45520.145    2412.9854    2412.9854 
Loop time of 84.3786 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.024 ns/day, 23.438 hours/ns, 11.851 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    | 83.652     | 83.652     | 83.652     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073113   | 0.073113   | 0.073113   |   0.0 |  0.09
Output  | 0.00083717 | 0.00083717 | 0.00083717 |   0.0 |  0.00
Modify  | 0.57127    | 0.57127    | 0.57127    |   0.0 |  0.68
Other   |            | 0.08165    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695196.0 ave      695196 max      695196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695196
Ave neighs/atom = 86.899500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.7313700609, Press = -2.87552065952401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -58398.167   -58398.167   -58680.801   -58680.801    273.35271    273.35271    45520.145    45520.145    2412.9854    2412.9854 
   20000   -58392.209   -58392.209   -58677.936   -58677.936     276.3449     276.3449    45525.951    45525.951    1974.0614    1974.0614 
Loop time of 84.5412 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.022 ns/day, 23.484 hours/ns, 11.829 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    | 83.815     | 83.815     | 83.815     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073174   | 0.073174   | 0.073174   |   0.0 |  0.09
Output  | 0.00014429 | 0.00014429 | 0.00014429 |   0.0 |  0.00
Modify  | 0.57158    | 0.57158    | 0.57158    |   0.0 |  0.68
Other   |            | 0.08152    |            |       |  0.10

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695046.0 ave      695046 max      695046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695046
Ave neighs/atom = 86.880750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.754236463185, Press = -3.85681345315561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -58392.209   -58392.209   -58677.936   -58677.936     276.3449     276.3449    45525.951    45525.951    1974.0614    1974.0614 
   21000   -58395.172   -58395.172   -58675.785   -58675.785     271.3984     271.3984    45534.953    45534.953    1195.4924    1195.4924 
Loop time of 84.257 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.025 ns/day, 23.405 hours/ns, 11.868 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    | 83.54      | 83.54      | 83.54      |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072412   | 0.072412   | 0.072412   |   0.0 |  0.09
Output  | 0.00012575 | 0.00012575 | 0.00012575 |   0.0 |  0.00
Modify  | 0.56652    | 0.56652    | 0.56652    |   0.0 |  0.67
Other   |            | 0.07763    |            |       |  0.09

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694936.0 ave      694936 max      694936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694936
Ave neighs/atom = 86.867000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.813349000575, Press = -4.42407203697895
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -58395.172   -58395.172   -58675.785   -58675.785     271.3984     271.3984    45534.953    45534.953    1195.4924    1195.4924 
   22000   -58392.978   -58392.978   -58676.526   -58676.526     274.2371     274.2371    45544.779    45544.779    162.82466    162.82466 
Loop time of 83.604 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.033 ns/day, 23.223 hours/ns, 11.961 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    | 82.909     | 82.909     | 82.909     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071097   | 0.071097   | 0.071097   |   0.0 |  0.09
Output  | 0.0001238  | 0.0001238  | 0.0001238  |   0.0 |  0.00
Modify  | 0.55368    | 0.55368    | 0.55368    |   0.0 |  0.66
Other   |            | 0.07039    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695018.0 ave      695018 max      695018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695018
Ave neighs/atom = 86.877250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.901724812369, Press = -4.30993120456182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -58392.978   -58392.978   -58676.526   -58676.526     274.2371     274.2371    45544.779    45544.779    162.82466    162.82466 
   23000   -58395.239   -58395.239   -58675.987   -58675.987    271.52894    271.52894    45550.088    45550.088   -361.01586   -361.01586 
Loop time of 83.719 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.032 ns/day, 23.255 hours/ns, 11.945 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    | 83.022     | 83.022     | 83.022     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071514   | 0.071514   | 0.071514   |   0.0 |  0.09
Output  | 0.00012259 | 0.00012259 | 0.00012259 |   0.0 |  0.00
Modify  | 0.55429    | 0.55429    | 0.55429    |   0.0 |  0.66
Other   |            | 0.07071    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694896.0 ave      694896 max      694896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694896
Ave neighs/atom = 86.862000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918816155105, Press = -2.81284054005649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -58395.239   -58395.239   -58675.987   -58675.987    271.52894    271.52894    45550.088    45550.088   -361.01586   -361.01586 
   24000   -58399.285   -58399.285   -58679.233   -58679.233     270.7546     270.7546     45548.92     45548.92   -308.52584   -308.52584 
Loop time of 83.7505 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.032 ns/day, 23.264 hours/ns, 11.940 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    | 83.054     | 83.054     | 83.054     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071249   | 0.071249   | 0.071249   |   0.0 |  0.09
Output  | 0.00012396 | 0.00012396 | 0.00012396 |   0.0 |  0.00
Modify  | 0.55505    | 0.55505    | 0.55505    |   0.0 |  0.66
Other   |            | 0.07046    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694756.0 ave      694756 max      694756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694756
Ave neighs/atom = 86.844500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946076281326, Press = -1.58098305294978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -58399.285   -58399.285   -58679.233   -58679.233     270.7546     270.7546     45548.92     45548.92   -308.52584   -308.52584 
   25000    -58392.21    -58392.21   -58672.582   -58672.582    271.16547    271.16547    45550.654    45550.654   -89.605417   -89.605417 
Loop time of 83.771 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.031 ns/day, 23.270 hours/ns, 11.937 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    | 83.075     | 83.075     | 83.075     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071476   | 0.071476   | 0.071476   |   0.0 |  0.09
Output  | 0.00012078 | 0.00012078 | 0.00012078 |   0.0 |  0.00
Modify  | 0.55413    | 0.55413    | 0.55413    |   0.0 |  0.66
Other   |            | 0.07018    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694746.0 ave      694746 max      694746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694746
Ave neighs/atom = 86.843250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.900433945433, Press = -1.11709475670063
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -58392.21    -58392.21   -58672.582   -58672.582    271.16547    271.16547    45550.654    45550.654   -89.605417   -89.605417 
   26000    -58399.25    -58399.25   -58680.143   -58680.143    271.66973    271.66973      45550.3      45550.3    -530.8741    -530.8741 
Loop time of 83.7576 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.032 ns/day, 23.266 hours/ns, 11.939 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    | 83.061     | 83.061     | 83.061     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071374   | 0.071374   | 0.071374   |   0.0 |  0.09
Output  | 0.000123   | 0.000123   | 0.000123   |   0.0 |  0.00
Modify  | 0.55439    | 0.55439    | 0.55439    |   0.0 |  0.66
Other   |            | 0.07033    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694894.0 ave      694894 max      694894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694894
Ave neighs/atom = 86.861750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.888146620808, Press = -1.26893585051437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -58399.25    -58399.25   -58680.143   -58680.143    271.66973    271.66973      45550.3      45550.3    -530.8741    -530.8741 
   27000   -58394.601   -58394.601   -58675.978   -58675.978    272.13742    272.13742    45557.817    45557.817   -869.78653   -869.78653 
Loop time of 83.4892 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.035 ns/day, 23.191 hours/ns, 11.978 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    | 82.795     | 82.795     | 82.795     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071149   | 0.071149   | 0.071149   |   0.0 |  0.09
Output  | 0.00012368 | 0.00012368 | 0.00012368 |   0.0 |  0.00
Modify  | 0.55305    | 0.55305    | 0.55305    |   0.0 |  0.66
Other   |            | 0.07008    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694888.0 ave      694888 max      694888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694888
Ave neighs/atom = 86.861000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.887585540986, Press = -0.87763619699424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -58394.601   -58394.601   -58675.978   -58675.978    272.13742    272.13742    45557.817    45557.817   -869.78653   -869.78653 
   28000    -58390.14    -58390.14   -58677.024   -58677.024    277.46319    277.46319    45561.224    45561.224   -1291.9831   -1291.9831 
Loop time of 83.8233 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.031 ns/day, 23.284 hours/ns, 11.930 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    | 83.125     | 83.125     | 83.125     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071163   | 0.071163   | 0.071163   |   0.0 |  0.08
Output  | 0.00013588 | 0.00013588 | 0.00013588 |   0.0 |  0.00
Modify  | 0.55534    | 0.55534    | 0.55534    |   0.0 |  0.66
Other   |            | 0.07115    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694826.0 ave      694826 max      694826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694826
Ave neighs/atom = 86.853250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.905072564761, Press = -0.265297670496535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -58390.14    -58390.14   -58677.024   -58677.024    277.46319    277.46319    45561.224    45561.224   -1291.9831   -1291.9831 
   29000   -58394.815   -58394.815   -58674.494   -58674.494    270.49542    270.49542     45566.38     45566.38    -1830.209    -1830.209 
Loop time of 83.7841 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.031 ns/day, 23.273 hours/ns, 11.935 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    | 83.087     | 83.087     | 83.087     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071298   | 0.071298   | 0.071298   |   0.0 |  0.09
Output  | 0.00012353 | 0.00012353 | 0.00012353 |   0.0 |  0.00
Modify  | 0.55516    | 0.55516    | 0.55516    |   0.0 |  0.66
Other   |            | 0.07084    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694686.0 ave      694686 max      694686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694686
Ave neighs/atom = 86.835750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.967795909597, Press = 0.908335721486949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -58394.815   -58394.815   -58674.494   -58674.494    270.49542    270.49542     45566.38     45566.38    -1830.209    -1830.209 
   30000   -58386.851   -58386.851   -58673.444   -58673.444    277.18232    277.18232    45566.026    45566.026   -1533.3222   -1533.3222 
Loop time of 83.7266 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.032 ns/day, 23.257 hours/ns, 11.944 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    | 83.031     | 83.031     | 83.031     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071052   | 0.071052   | 0.071052   |   0.0 |  0.08
Output  | 0.00012127 | 0.00012127 | 0.00012127 |   0.0 |  0.00
Modify  | 0.55397    | 0.55397    | 0.55397    |   0.0 |  0.66
Other   |            | 0.07069    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694776.0 ave      694776 max      694776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694776
Ave neighs/atom = 86.847000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.004424026321, Press = 2.11415893078703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -58386.851   -58386.851   -58673.444   -58673.444    277.18232    277.18232    45566.026    45566.026   -1533.3222   -1533.3222 
   31000   -58392.114   -58392.114    -58673.37    -58673.37    272.02028    272.02028    45548.958    45548.958   -65.952451   -65.952451 
Loop time of 83.9114 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.030 ns/day, 23.309 hours/ns, 11.917 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    | 83.215     | 83.215     | 83.215     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071364   | 0.071364   | 0.071364   |   0.0 |  0.09
Output  | 0.00012603 | 0.00012603 | 0.00012603 |   0.0 |  0.00
Modify  | 0.55373    | 0.55373    | 0.55373    |   0.0 |  0.66
Other   |            | 0.07101    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694670.0 ave      694670 max      694670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694670
Ave neighs/atom = 86.833750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.99294369688, Press = 1.98077493673781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -58392.114   -58392.114    -58673.37    -58673.37    272.02028    272.02028    45548.958    45548.958   -65.952451   -65.952451 
   32000   -58400.449   -58400.449   -58681.278   -58681.278     271.6073     271.6073    45540.693    45540.693    255.15212    255.15212 
Loop time of 82.9374 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.042 ns/day, 23.038 hours/ns, 12.057 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 82.253     | 82.253     | 82.253     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070424   | 0.070424   | 0.070424   |   0.0 |  0.08
Output  | 0.0001211  | 0.0001211  | 0.0001211  |   0.0 |  0.00
Modify  | 0.54626    | 0.54626    | 0.54626    |   0.0 |  0.66
Other   |            | 0.06744    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694788.0 ave      694788 max      694788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694788
Ave neighs/atom = 86.848500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.967137955919, Press = 0.213652643428409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -58400.449   -58400.449   -58681.278   -58681.278     271.6073     271.6073    45540.693    45540.693    255.15212    255.15212 
   33000   -58391.732   -58391.732   -58672.276   -58672.276    271.33127    271.33127    45541.829    45541.829    690.96144    690.96144 
Loop time of 82.7329 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.044 ns/day, 22.981 hours/ns, 12.087 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    | 82.052     | 82.052     | 82.052     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069923   | 0.069923   | 0.069923   |   0.0 |  0.08
Output  | 0.00011838 | 0.00011838 | 0.00011838 |   0.0 |  0.00
Modify  | 0.54417    | 0.54417    | 0.54417    |   0.0 |  0.66
Other   |            | 0.06708    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694628.0 ave      694628 max      694628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694628
Ave neighs/atom = 86.828500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.941464667581, Press = -0.270107752594015
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -58391.732   -58391.732   -58672.276   -58672.276    271.33127    271.33127    45541.829    45541.829    690.96144    690.96144 
   34000   -58387.307   -58387.307   -58674.146   -58674.146    277.42034    277.42034    45542.579    45542.579    626.03447    626.03447 
Loop time of 82.6031 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.046 ns/day, 22.945 hours/ns, 12.106 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    | 81.921     | 81.921     | 81.921     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070237   | 0.070237   | 0.070237   |   0.0 |  0.09
Output  | 0.00011915 | 0.00011915 | 0.00011915 |   0.0 |  0.00
Modify  | 0.54442    | 0.54442    | 0.54442    |   0.0 |  0.66
Other   |            | 0.06701    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694900.0 ave      694900 max      694900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694900
Ave neighs/atom = 86.862500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936839953629, Press = -0.439215563902388
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -58387.307   -58387.307   -58674.146   -58674.146    277.42034    277.42034    45542.579    45542.579    626.03447    626.03447 
   35000   -58395.012   -58395.012   -58676.816   -58676.816    272.55026    272.55026    45530.842    45530.842    1550.4289    1550.4289 
Loop time of 82.8244 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.043 ns/day, 23.007 hours/ns, 12.074 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    | 82.143     | 82.143     | 82.143     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069873   | 0.069873   | 0.069873   |   0.0 |  0.08
Output  | 0.00012079 | 0.00012079 | 0.00012079 |   0.0 |  0.00
Modify  | 0.54417    | 0.54417    | 0.54417    |   0.0 |  0.66
Other   |            | 0.06687    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694874.0 ave      694874 max      694874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694874
Ave neighs/atom = 86.859250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.967774349263, Press = -0.334164988266136
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -58395.012   -58395.012   -58676.816   -58676.816    272.55026    272.55026    45530.842    45530.842    1550.4289    1550.4289 
   36000   -58393.442   -58393.442   -58675.065   -58675.065    272.37564    272.37564     45520.27     45520.27    2571.1968    2571.1968 
Loop time of 82.6143 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.046 ns/day, 22.948 hours/ns, 12.104 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 81.933     | 81.933     | 81.933     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069932   | 0.069932   | 0.069932   |   0.0 |  0.08
Output  | 0.00011094 | 0.00011094 | 0.00011094 |   0.0 |  0.00
Modify  | 0.54437    | 0.54437    | 0.54437    |   0.0 |  0.66
Other   |            | 0.0671     |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694894.0 ave      694894 max      694894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694894
Ave neighs/atom = 86.861750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017098194888, Press = -0.767653036411844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -58393.442   -58393.442   -58675.065   -58675.065    272.37564    272.37564     45520.27     45520.27    2571.1968    2571.1968 
   37000   -58388.686   -58388.686   -58674.595   -58674.595    276.52054    276.52054    45522.689    45522.689    2388.2184    2388.2184 
Loop time of 82.6435 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.957 hours/ns, 12.100 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    | 81.963     | 81.963     | 81.963     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069857   | 0.069857   | 0.069857   |   0.0 |  0.08
Output  | 0.00012012 | 0.00012012 | 0.00012012 |   0.0 |  0.00
Modify  | 0.54366    | 0.54366    | 0.54366    |   0.0 |  0.66
Other   |            | 0.06664    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695488.0 ave      695488 max      695488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695488
Ave neighs/atom = 86.936000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.031813775938, Press = -1.31979081876128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -58388.686   -58388.686   -58674.595   -58674.595    276.52054    276.52054    45522.689    45522.689    2388.2184    2388.2184 
   38000   -58394.534   -58394.534   -58675.632   -58675.632    271.86771    271.86771    45527.248    45527.248    1822.0766    1822.0766 
Loop time of 82.7915 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.044 ns/day, 22.998 hours/ns, 12.079 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    | 82.11      | 82.11      | 82.11      |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070395   | 0.070395   | 0.070395   |   0.0 |  0.09
Output  | 0.00011995 | 0.00011995 | 0.00011995 |   0.0 |  0.00
Modify  | 0.54394    | 0.54394    | 0.54394    |   0.0 |  0.66
Other   |            | 0.06689    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695322.0 ave      695322 max      695322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695322
Ave neighs/atom = 86.915250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.023365762843, Press = -1.99219430218378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -58394.534   -58394.534   -58675.632   -58675.632    271.86771    271.86771    45527.248    45527.248    1822.0766    1822.0766 
   39000    -58399.09    -58399.09   -58680.303   -58680.303    271.97906    271.97906    45531.607    45531.607    1205.3107    1205.3107 
Loop time of 82.8144 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.043 ns/day, 23.004 hours/ns, 12.075 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    | 82.133     | 82.133     | 82.133     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070075   | 0.070075   | 0.070075   |   0.0 |  0.08
Output  | 0.00012132 | 0.00012132 | 0.00012132 |   0.0 |  0.00
Modify  | 0.5445     | 0.5445     | 0.5445     |   0.0 |  0.66
Other   |            | 0.06708    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      695264.0 ave      695264 max      695264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695264
Ave neighs/atom = 86.908000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.007468964748, Press = -2.39049976204532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -58399.09    -58399.09   -58680.303   -58680.303    271.97906    271.97906    45531.607    45531.607    1205.3107    1205.3107 
   40000   -58391.092   -58391.092   -58674.112   -58674.112      273.727      273.727    45548.061    45548.061    38.212974    38.212974 
Loop time of 82.6728 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.965 hours/ns, 12.096 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    | 81.992     | 81.992     | 81.992     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070256   | 0.070256   | 0.070256   |   0.0 |  0.08
Output  | 0.0001196  | 0.0001196  | 0.0001196  |   0.0 |  0.00
Modify  | 0.54355    | 0.54355    | 0.54355    |   0.0 |  0.66
Other   |            | 0.0669     |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694934.0 ave      694934 max      694934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694934
Ave neighs/atom = 86.866750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.980095437477, Press = -2.25501756456996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -58391.092   -58391.092   -58674.112   -58674.112      273.727      273.727    45548.061    45548.061    38.212974    38.212974 
   41000   -58388.067   -58388.067   -58672.597   -58672.597    275.18693    275.18693    45558.791    45558.791   -690.76898   -690.76898 
Loop time of 82.6259 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.046 ns/day, 22.952 hours/ns, 12.103 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    | 81.946     | 81.946     | 81.946     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069794   | 0.069794   | 0.069794   |   0.0 |  0.08
Output  | 0.00011943 | 0.00011943 | 0.00011943 |   0.0 |  0.00
Modify  | 0.54339    | 0.54339    | 0.54339    |   0.0 |  0.66
Other   |            | 0.06681    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694956.0 ave      694956 max      694956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694956
Ave neighs/atom = 86.869500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.973514061761, Press = -1.92895019252041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -58388.067   -58388.067   -58672.597   -58672.597    275.18693    275.18693    45558.791    45558.791   -690.76898   -690.76898 
   42000   -58395.322   -58395.322   -58677.751   -58677.751    273.15435    273.15435    45560.424    45560.424   -1230.1567   -1230.1567 
Loop time of 82.6842 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.968 hours/ns, 12.094 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    | 82.004     | 82.004     | 82.004     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069863   | 0.069863   | 0.069863   |   0.0 |  0.08
Output  | 0.00011972 | 0.00011972 | 0.00011972 |   0.0 |  0.00
Modify  | 0.54354    | 0.54354    | 0.54354    |   0.0 |  0.66
Other   |            | 0.06667    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694640.0 ave      694640 max      694640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694640
Ave neighs/atom = 86.830000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.003602455797, Press = -1.44632046094136
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -58395.322   -58395.322   -58677.751   -58677.751    273.15435    273.15435    45560.424    45560.424   -1230.1567   -1230.1567 
   43000   -58390.022   -58390.022   -58672.051   -58672.051    272.76752    272.76752    45568.033    45568.033   -1575.1151   -1575.1151 
Loop time of 82.6468 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.957 hours/ns, 12.100 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    | 81.966     | 81.966     | 81.966     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069903   | 0.069903   | 0.069903   |   0.0 |  0.08
Output  | 0.00012243 | 0.00012243 | 0.00012243 |   0.0 |  0.00
Modify  | 0.54424    | 0.54424    | 0.54424    |   0.0 |  0.66
Other   |            | 0.06697    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694562.0 ave      694562 max      694562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694562
Ave neighs/atom = 86.820250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.040802020323, Press = -1.24107256178816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -58390.022   -58390.022   -58672.051   -58672.051    272.76752    272.76752    45568.033    45568.033   -1575.1151   -1575.1151 
   44000    -58389.99    -58389.99   -58672.967   -58672.967     273.6849     273.6849    45586.476    45586.476    -3433.033    -3433.033 
Loop time of 82.7048 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.974 hours/ns, 12.091 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 82.024     | 82.024     | 82.024     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069717   | 0.069717   | 0.069717   |   0.0 |  0.08
Output  | 0.0001179  | 0.0001179  | 0.0001179  |   0.0 |  0.00
Modify  | 0.54395    | 0.54395    | 0.54395    |   0.0 |  0.66
Other   |            | 0.06682    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694538.0 ave      694538 max      694538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 694538
Ave neighs/atom = 86.817250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.052067933302, Press = -1.16210861132551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5
  ghost atom cutoff = 5
  binsize = 2.5, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 10.81 | 10.81 | 10.81 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -58389.99    -58389.99   -58672.967   -58672.967     273.6849     273.6849    45586.476    45586.476    -3433.033    -3433.033 
   45000   -58395.548   -58395.548   -58675.613   -58675.613    270.86868    270.86868    45599.207    45599.207   -4703.7053   -4703.7053 
Loop time of 82.683 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.045 ns/day, 22.967 hours/ns, 12.094 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    | 82.002     | 82.002     | 82.002     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069947   | 0.069947   | 0.069947   |   0.0 |  0.08
Output  | 0.0001189  | 0.0001189  | 0.0001189  |   0.0 |  0.00
Modify  | 0.54394    | 0.54394    | 0.54394    |   0.0 |  0.66
Other   |            | 0.06684    |            |       |  0.08

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8601.00 ave        8601 max        8601 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:      694530.0 ave      694530 max      694530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0