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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

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


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13298.806     -13298.806     -13440         -13440          273.15         273.15         66167.25       66167.25       2279.2647      2279.2647    
      1000  -13142.635     -13142.635     -13293.562     -13293.562      291.97878      291.97878      67223.957      67223.957      795.29344      795.29344    
Loop time of 56.6422 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.525 ns/day, 15.734 hours/ns, 17.655 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 56.491     | 56.491     | 56.491     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02206    | 0.02206    | 0.02206    |   0.0 |  0.04
Output  | 0.00012728 | 0.00012728 | 0.00012728 |   0.0 |  0.00
Modify  | 0.11859    | 0.11859    | 0.11859    |   0.0 |  0.21
Other   |            | 0.01054    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13142.635     -13142.635     -13293.562     -13293.562      291.97878      291.97878      67223.957      67223.957      795.29344      795.29344    
      2000  -13158.022     -13158.022     -13294.667     -13294.667      264.34952      264.34952      67217.314      67217.314      548.24427      548.24427    
Loop time of 61.2978 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.027 hours/ns, 16.314 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.148     | 61.148     | 61.148     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021892   | 0.021892   | 0.021892   |   0.0 |  0.04
Output  | 5.5243e-05 | 5.5243e-05 | 5.5243e-05 |   0.0 |  0.00
Modify  | 0.11804    | 0.11804    | 0.11804    |   0.0 |  0.19
Other   |            | 0.01034    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284198 ave      284198 max      284198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284198
Ave neighs/atom = 71.0495
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13158.022     -13158.022     -13294.667     -13294.667      264.34952      264.34952      67217.314      67217.314      548.24427      548.24427    
      3000  -13148.555     -13148.555     -13286.704     -13286.704      267.2576       267.2576       67264.926      67264.926      488.09485      488.09485    
Loop time of 61.3088 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.409 ns/day, 17.030 hours/ns, 16.311 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.159     | 61.159     | 61.159     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021736   | 0.021736   | 0.021736   |   0.0 |  0.04
Output  | 6.3789e-05 | 6.3789e-05 | 6.3789e-05 |   0.0 |  0.00
Modify  | 0.11795    | 0.11795    | 0.11795    |   0.0 |  0.19
Other   |            | 0.01035    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284358 ave      284358 max      284358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284358
Ave neighs/atom = 71.0895
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13148.555     -13148.555     -13286.704     -13286.704      267.2576       267.2576       67264.926      67264.926      488.09485      488.09485    
      4000  -13155.153     -13155.153     -13294.877     -13294.877      270.30611      270.30611      67251.439      67251.439      129.44704      129.44704    
Loop time of 60.9142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.921 hours/ns, 16.417 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.765     | 60.765     | 60.765     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021624   | 0.021624   | 0.021624   |   0.0 |  0.04
Output  | 5.9121e-05 | 5.9121e-05 | 5.9121e-05 |   0.0 |  0.00
Modify  | 0.11744    | 0.11744    | 0.11744    |   0.0 |  0.19
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283000 ave      283000 max      283000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283000
Ave neighs/atom = 70.75
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13155.153     -13155.153     -13294.877     -13294.877      270.30611      270.30611      67251.439      67251.439      129.44704      129.44704    
      5000  -13152.484     -13152.484     -13293.204     -13293.204      272.23304      272.23304      67249.092      67249.092      312.25743      312.25743    
Loop time of 61.1893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.997 hours/ns, 16.343 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.039     | 61.039     | 61.039     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.04
Output  | 4.826e-05  | 4.826e-05  | 4.826e-05  |   0.0 |  0.00
Modify  | 0.11811    | 0.11811    | 0.11811    |   0.0 |  0.19
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284036 ave      284036 max      284036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284036
Ave neighs/atom = 71.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.979038742259, Press = 251.214941747292
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13152.484     -13152.484     -13293.204     -13293.204      272.23304      272.23304      67249.092      67249.092      312.25743      312.25743    
      6000  -13150.848     -13150.848     -13290.929     -13290.929      270.99692      270.99692      67244.098      67244.098      526.25994      526.25994    
Loop time of 61.0707 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.964 hours/ns, 16.374 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.917     | 60.917     | 60.917     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021866   | 0.021866   | 0.021866   |   0.0 |  0.04
Output  | 4.8191e-05 | 4.8191e-05 | 4.8191e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.20
Other   |            | 0.01051    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283864 ave      283864 max      283864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283864
Ave neighs/atom = 70.966
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.681771077992, Press = 41.1029824238852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13150.848     -13150.848     -13290.929     -13290.929      270.99692      270.99692      67244.098      67244.098      526.25994      526.25994    
      7000  -13154.266     -13154.266     -13293.225     -13293.225      268.82541      268.82541      67252.681      67252.681      169.47177      169.47177    
Loop time of 61.2475 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.411 ns/day, 17.013 hours/ns, 16.327 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.093     | 61.093     | 61.093     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021866   | 0.021866   | 0.021866   |   0.0 |  0.04
Output  | 4.6358e-05 | 4.6358e-05 | 4.6358e-05 |   0.0 |  0.00
Modify  | 0.12165    | 0.12165    | 0.12165    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283854 ave      283854 max      283854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283854
Ave neighs/atom = 70.9635
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.171027959684, Press = 28.7074532696939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13154.266     -13154.266     -13293.225     -13293.225      268.82541      268.82541      67252.681      67252.681      169.47177      169.47177    
      8000  -13151.419     -13151.419     -13294.205     -13294.205      276.22776      276.22776      67297.324      67297.324     -306.63877     -306.63877    
Loop time of 61.1058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.974 hours/ns, 16.365 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.952     | 60.952     | 60.952     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02194    | 0.02194    | 0.02194    |   0.0 |  0.04
Output  | 4.6297e-05 | 4.6297e-05 | 4.6297e-05 |   0.0 |  0.00
Modify  | 0.12176    | 0.12176    | 0.12176    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283554 ave      283554 max      283554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283554
Ave neighs/atom = 70.8885
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.959350251593, Press = 13.6467416232699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13151.419     -13151.419     -13294.205     -13294.205      276.22776      276.22776      67297.324      67297.324     -306.63877     -306.63877    
      9000  -13151.999     -13151.999     -13294.851     -13294.851      276.35697      276.35697      67292.031      67292.031     -260.2849      -260.2849     
Loop time of 61.2173 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.411 ns/day, 17.005 hours/ns, 16.335 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.063     | 61.063     | 61.063     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.04
Output  | 5.0375e-05 | 5.0375e-05 | 5.0375e-05 |   0.0 |  0.00
Modify  | 0.12203    | 0.12203    | 0.12203    |   0.0 |  0.20
Other   |            | 0.01054    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283814 ave      283814 max      283814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283814
Ave neighs/atom = 70.9535
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.857123446014, Press = 7.58949512413874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13151.999     -13151.999     -13294.851     -13294.851      276.35697      276.35697      67292.031      67292.031     -260.2849      -260.2849     
     10000  -13156.958     -13156.958     -13295.09      -13295.09       267.22667      267.22667      67262.272      67262.272     -21.706269     -21.706269    
Loop time of 61.3104 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.409 ns/day, 17.031 hours/ns, 16.310 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.157     | 61.157     | 61.157     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02154    | 0.02154    | 0.02154    |   0.0 |  0.04
Output  | 4.4404e-05 | 4.4404e-05 | 4.4404e-05 |   0.0 |  0.00
Modify  | 0.12175    | 0.12175    | 0.12175    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283788 ave      283788 max      283788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283788
Ave neighs/atom = 70.947
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.874009522496, Press = 2.23787795795793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13156.958     -13156.958     -13295.09      -13295.09       267.22667      267.22667      67262.272      67262.272     -21.706269     -21.706269    
     11000  -13156.054     -13156.054     -13296.002     -13296.002      270.73908      270.73908      67271.302      67271.302     -219.37299     -219.37299    
Loop time of 61.3407 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.409 ns/day, 17.039 hours/ns, 16.302 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.187     | 61.187     | 61.187     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021541   | 0.021541   | 0.021541   |   0.0 |  0.04
Output  | 4.6327e-05 | 4.6327e-05 | 4.6327e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283888 ave      283888 max      283888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283888
Ave neighs/atom = 70.972
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.776550053376, Press = 1.4521546119427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13156.054     -13156.054     -13296.002     -13296.002      270.73908      270.73908      67271.302      67271.302     -219.37299     -219.37299    
     12000  -13151.121     -13151.121     -13292.622     -13292.622      273.7426       273.7426       67323.261      67323.261     -463.74219     -463.74219    
Loop time of 61.1951 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.999 hours/ns, 16.341 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.042     | 61.042     | 61.042     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021402   | 0.021402   | 0.021402   |   0.0 |  0.03
Output  | 5.29e-05   | 5.29e-05   | 5.29e-05   |   0.0 |  0.00
Modify  | 0.12155    | 0.12155    | 0.12155    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283870 ave      283870 max      283870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283870
Ave neighs/atom = 70.9675
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.814248436367, Press = -0.13584349718969
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13151.121     -13151.121     -13292.622     -13292.622      273.7426       273.7426       67323.261      67323.261     -463.74219     -463.74219    
     13000  -13157.322     -13157.322     -13296.816     -13296.816      269.86073      269.86073      67296.851      67296.851     -537.67722     -537.67722    
Loop time of 61.1012 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.973 hours/ns, 16.366 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.948     | 60.948     | 60.948     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021568   | 0.021568   | 0.021568   |   0.0 |  0.04
Output  | 4.8912e-05 | 4.8912e-05 | 4.8912e-05 |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283396 ave      283396 max      283396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283396
Ave neighs/atom = 70.849
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.671444611633, Press = -1.03962480446437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13157.322     -13157.322     -13296.816     -13296.816      269.86073      269.86073      67296.851      67296.851     -537.67722     -537.67722    
     14000  -13153.13      -13153.13      -13293.482     -13293.482      271.52121      271.52121      67300.352      67300.352     -353.05275     -353.05275    
Loop time of 61.0984 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.972 hours/ns, 16.367 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.945     | 60.945     | 60.945     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021434   | 0.021434   | 0.021434   |   0.0 |  0.04
Output  | 4.6026e-05 | 4.6026e-05 | 4.6026e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283848 ave      283848 max      283848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283848
Ave neighs/atom = 70.962
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.686497533306, Press = -2.73419034628403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13153.13      -13153.13      -13293.482     -13293.482      271.52121      271.52121      67300.352      67300.352     -353.05275     -353.05275    
     15000  -13150.424     -13150.424     -13291.365     -13291.365      272.66144      272.66144      67280.649      67280.649      27.835759      27.835759    
Loop time of 61.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.981 hours/ns, 16.358 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.978     | 60.978     | 60.978     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02145    | 0.02145    | 0.02145    |   0.0 |  0.04
Output  | 4.5185e-05 | 4.5185e-05 | 4.5185e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283462 ave      283462 max      283462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283462
Ave neighs/atom = 70.8655
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.674760702507, Press = -1.96943842000921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13150.424     -13150.424     -13291.365     -13291.365      272.66144      272.66144      67280.649      67280.649      27.835759      27.835759    
     16000  -13152.074     -13152.074     -13292.312     -13292.312      271.2992       271.2992       67270.297      67270.297      86.010126      86.010126    
Loop time of 61.1767 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.994 hours/ns, 16.346 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.023     | 61.023     | 61.023     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021484   | 0.021484   | 0.021484   |   0.0 |  0.04
Output  | 4.6076e-05 | 4.6076e-05 | 4.6076e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.20
Other   |            | 0.01048    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283442 ave      283442 max      283442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283442
Ave neighs/atom = 70.8605
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.783235647718, Press = -0.234193937940502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13152.074     -13152.074     -13292.312     -13292.312      271.2992       271.2992       67270.297      67270.297      86.010126      86.010126    
     17000  -13160.907     -13160.907     -13298.495     -13298.495      266.17329      266.17329      67221.982      67221.982      191.19441      191.19441    
Loop time of 61.2107 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 17.003 hours/ns, 16.337 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.057     | 61.057     | 61.057     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02142    | 0.02142    | 0.02142    |   0.0 |  0.03
Output  | 4.4994e-05 | 4.4994e-05 | 4.4994e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283560 ave      283560 max      283560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283560
Ave neighs/atom = 70.89
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.729653068115, Press = -0.245119920970751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13160.907     -13160.907     -13298.495     -13298.495      266.17329      266.17329      67221.982      67221.982      191.19441      191.19441    
     18000  -13151.315     -13151.315     -13293.506     -13293.506      275.07811      275.07811      67240.085      67240.085      439.24239      439.24239    
Loop time of 61.2398 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.411 ns/day, 17.011 hours/ns, 16.329 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.086     | 61.086     | 61.086     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021433   | 0.021433   | 0.021433   |   0.0 |  0.03
Output  | 4.8411e-05 | 4.8411e-05 | 4.8411e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284534 ave      284534 max      284534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284534
Ave neighs/atom = 71.1335
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.630087472826, Press = -0.648890295193552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13151.315     -13151.315     -13293.506     -13293.506      275.07811      275.07811      67240.085      67240.085      439.24239      439.24239    
     19000  -13153.673     -13153.673     -13293.152     -13293.152      269.83214      269.83214      67193.283      67193.283      981.11814      981.11814    
Loop time of 61.2722 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.020 hours/ns, 16.321 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.119     | 61.119     | 61.119     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021602   | 0.021602   | 0.021602   |   0.0 |  0.04
Output  | 4.5866e-05 | 4.5866e-05 | 4.5866e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.20
Other   |            | 0.01052    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284138 ave      284138 max      284138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284138
Ave neighs/atom = 71.0345
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.670901814581, Press = -0.35880983127792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13153.673     -13153.673     -13293.152     -13293.152      269.83214      269.83214      67193.283      67193.283      981.11814      981.11814    
     20000  -13148.85      -13148.85      -13288.566     -13288.566      270.29019      270.29019      67179.976      67179.976      1420.035       1420.035     
Loop time of 61.1527 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.987 hours/ns, 16.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.999     | 60.999     | 60.999     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021415   | 0.021415   | 0.021415   |   0.0 |  0.04
Output  | 4.5275e-05 | 4.5275e-05 | 4.5275e-05 |   0.0 |  0.00
Modify  | 0.12153    | 0.12153    | 0.12153    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284348 ave      284348 max      284348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284348
Ave neighs/atom = 71.087
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.68650657827, Press = 0.439698492075115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13148.85      -13148.85      -13288.566     -13288.566      270.29019      270.29019      67179.976      67179.976      1420.035       1420.035     
     21000  -13153.907     -13153.907     -13294.485     -13294.485      271.9571       271.9571       67154.276      67154.276      1285.5785      1285.5785    
Loop time of 61.2053 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 17.001 hours/ns, 16.338 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.052     | 61.052     | 61.052     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021457   | 0.021457   | 0.021457   |   0.0 |  0.04
Output  | 4.4774e-05 | 4.4774e-05 | 4.4774e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284210 ave      284210 max      284210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284210
Ave neighs/atom = 71.0525
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.767099488383, Press = 1.23750915164971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13153.907     -13153.907     -13294.485     -13294.485      271.9571       271.9571       67154.276      67154.276      1285.5785      1285.5785    
     22000  -13153.577     -13153.577     -13294.313     -13294.313      272.26337      272.26337      67213.577      67213.577      627.39432      627.39432    
Loop time of 61.1907 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.997 hours/ns, 16.342 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.037     | 61.037     | 61.037     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021481   | 0.021481   | 0.021481   |   0.0 |  0.04
Output  | 4.5365e-05 | 4.5365e-05 | 4.5365e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.20
Other   |            | 0.01052    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284720 ave      284720 max      284720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284720
Ave neighs/atom = 71.18
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.793409002302, Press = 0.987589436831992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13153.577     -13153.577     -13294.313     -13294.313      272.26337      272.26337      67213.577      67213.577      627.39432      627.39432    
     23000  -13152.527     -13152.527     -13293.388     -13293.388      272.50584      272.50584      67245.795      67245.795      315.47228      315.47228    
Loop time of 61.1539 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.987 hours/ns, 16.352 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61         | 61         | 61         |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021392   | 0.021392   | 0.021392   |   0.0 |  0.03
Output  | 4.5866e-05 | 4.5866e-05 | 4.5866e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284406 ave      284406 max      284406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284406
Ave neighs/atom = 71.1015
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.780364300864, Press = 1.29057408604768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13152.527     -13152.527     -13293.388     -13293.388      272.50584      272.50584      67245.795      67245.795      315.47228      315.47228    
     24000  -13153.833     -13153.833     -13294.758     -13294.758      272.63053      272.63053      67263.73       67263.73       6.2045641      6.2045641    
Loop time of 61.0267 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.952 hours/ns, 16.386 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.873     | 60.873     | 60.873     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021377   | 0.021377   | 0.021377   |   0.0 |  0.04
Output  | 4.6408e-05 | 4.6408e-05 | 4.6408e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.20
Other   |            | 0.01048    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283926 ave      283926 max      283926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283926
Ave neighs/atom = 70.9815
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.774371864256, Press = 1.09479817869295
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13153.833     -13153.833     -13294.758     -13294.758      272.63053      272.63053      67263.73       67263.73       6.2045641      6.2045641    
     25000  -13151.71      -13151.71      -13293.249     -13293.249      273.81569      273.81569      67301.262      67301.262     -364.50406     -364.50406    
Loop time of 61.0843 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.968 hours/ns, 16.371 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.931     | 60.931     | 60.931     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02149    | 0.02149    | 0.02149    |   0.0 |  0.04
Output  | 4.6047e-05 | 4.6047e-05 | 4.6047e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283746 ave      283746 max      283746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283746
Ave neighs/atom = 70.9365
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.692364130808, Press = 0.675177005414569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13151.71      -13151.71      -13293.249     -13293.249      273.81569      273.81569      67301.262      67301.262     -364.50406     -364.50406    
     26000  -13152.303     -13152.303     -13293.031     -13293.031      272.24893      272.24893      67307.475      67307.475     -393.94655     -393.94655    
Loop time of 61.0808 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.967 hours/ns, 16.372 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.928     | 60.928     | 60.928     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021373   | 0.021373   | 0.021373   |   0.0 |  0.03
Output  | 4.4654e-05 | 4.4654e-05 | 4.4654e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283510 ave      283510 max      283510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283510
Ave neighs/atom = 70.8775
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.763737191519, Press = 0.475195906549772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13152.303     -13152.303     -13293.031     -13293.031      272.24893      272.24893      67307.475      67307.475     -393.94655     -393.94655    
     27000  -13158.916     -13158.916     -13297.292     -13297.292      267.69875      267.69875      67288.923      67288.923     -493.55766     -493.55766    
Loop time of 61.2039 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 17.001 hours/ns, 16.339 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.051     | 61.051     | 61.051     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02135    | 0.02135    | 0.02135    |   0.0 |  0.03
Output  | 4.4414e-05 | 4.4414e-05 | 4.4414e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283550 ave      283550 max      283550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283550
Ave neighs/atom = 70.8875
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.697694084097, Press = -0.0775935584107258
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13158.916     -13158.916     -13297.292     -13297.292      267.69875      267.69875      67288.923      67288.923     -493.55766     -493.55766    
     28000  -13150.872     -13150.872     -13292.541     -13292.541      274.06971      274.06971      67278.442      67278.442     -37.432786     -37.432786    
Loop time of 61.0896 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.969 hours/ns, 16.369 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.936     | 60.936     | 60.936     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021447   | 0.021447   | 0.021447   |   0.0 |  0.04
Output  | 4.5436e-05 | 4.5436e-05 | 4.5436e-05 |   0.0 |  0.00
Modify  | 0.12134    | 0.12134    | 0.12134    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283902 ave      283902 max      283902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283902
Ave neighs/atom = 70.9755
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.688220492681, Press = -1.03527866955931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13150.872     -13150.872     -13292.541     -13292.541      274.06971      274.06971      67278.442      67278.442     -37.432786     -37.432786    
     29000  -13150.893     -13150.893     -13292.71      -13292.71       274.35445      274.35445      67240.186      67240.186      416.74051      416.74051    
Loop time of 61.1543 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.987 hours/ns, 16.352 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.001     | 61.001     | 61.001     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021467   | 0.021467   | 0.021467   |   0.0 |  0.04
Output  | 4.8642e-05 | 4.8642e-05 | 4.8642e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283462 ave      283462 max      283462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283462
Ave neighs/atom = 70.8655
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.725243908202, Press = -1.23707057946741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13150.893     -13150.893     -13292.71      -13292.71       274.35445      274.35445      67240.186      67240.186      416.74051      416.74051    
     30000  -13157.491     -13157.491     -13298.586     -13298.586      272.95685      272.95685      67190.733      67190.733      568.45183      568.45183    
Loop time of 61.1777 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.994 hours/ns, 16.346 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.024     | 61.024     | 61.024     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02139    | 0.02139    | 0.02139    |   0.0 |  0.03
Output  | 4.5496e-05 | 4.5496e-05 | 4.5496e-05 |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283898 ave      283898 max      283898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283898
Ave neighs/atom = 70.9745
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.702379733112, Press = -0.415876930234379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13157.491     -13157.491     -13298.586     -13298.586      272.95685      272.95685      67190.733      67190.733      568.45183      568.45183    
     31000  -13152.547     -13152.547     -13292.699     -13292.699      271.13331      271.13331      67247.086      67247.086      281.93135      281.93135    
Loop time of 61.1812 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.995 hours/ns, 16.345 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.028     | 61.028     | 61.028     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021403   | 0.021403   | 0.021403   |   0.0 |  0.03
Output  | 5.0475e-05 | 5.0475e-05 | 5.0475e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284694 ave      284694 max      284694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284694
Ave neighs/atom = 71.1735
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.67766388091, Press = 0.168467665436606
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13152.547     -13152.547     -13292.699     -13292.699      271.13331      271.13331      67247.086      67247.086      281.93135      281.93135    
     32000  -13148.65      -13148.65      -13290.81      -13290.81       275.01797      275.01797      67260.648      67260.648      335.22861      335.22861    
Loop time of 61.1306 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.981 hours/ns, 16.358 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.977     | 60.977     | 60.977     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021499   | 0.021499   | 0.021499   |   0.0 |  0.04
Output  | 5.2358e-05 | 5.2358e-05 | 5.2358e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283920 ave      283920 max      283920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283920
Ave neighs/atom = 70.98
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.715329402698, Press = 0.184667713120844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13148.65      -13148.65      -13290.81      -13290.81       275.01797      275.01797      67260.648      67260.648      335.22861      335.22861    
     33000  -13154.849     -13154.849     -13294.597     -13294.597      270.35243      270.35243      67238.154      67238.154      318.54313      318.54313    
Loop time of 61.1087 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.975 hours/ns, 16.364 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.956     | 60.956     | 60.956     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021395   | 0.021395   | 0.021395   |   0.0 |  0.04
Output  | 4.5415e-05 | 4.5415e-05 | 4.5415e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283566 ave      283566 max      283566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283566
Ave neighs/atom = 70.8915
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.782341733441, Press = 0.487668673560894
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13154.849     -13154.849     -13294.597     -13294.597      270.35243      270.35243      67238.154      67238.154      318.54313      318.54313    
     34000  -13148.978     -13148.978     -13292.992     -13292.992      278.60539      278.60539      67215.639      67215.639      714.92168      714.92168    
Loop time of 61.1502 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.986 hours/ns, 16.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.997     | 60.997     | 60.997     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021324   | 0.021324   | 0.021324   |   0.0 |  0.03
Output  | 5.1978e-05 | 5.1978e-05 | 5.1978e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284048 ave      284048 max      284048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284048
Ave neighs/atom = 71.012
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.757794888408, Press = 0.981169651483455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13148.978     -13148.978     -13292.992     -13292.992      278.60539      278.60539      67215.639      67215.639      714.92168      714.92168    
     35000  -13155.223     -13155.223     -13293.716     -13293.716      267.92404      267.92404      67183.202      67183.202      997.20368      997.20368    
Loop time of 61.0781 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.966 hours/ns, 16.372 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.925     | 60.925     | 60.925     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021349   | 0.021349   | 0.021349   |   0.0 |  0.03
Output  | 4.4203e-05 | 4.4203e-05 | 4.4203e-05 |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283932 ave      283932 max      283932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283932
Ave neighs/atom = 70.983
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.749253913056, Press = 1.15363097593142
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13155.223     -13155.223     -13293.716     -13293.716      267.92404      267.92404      67183.202      67183.202      997.20368      997.20368    
     36000  -13149.187     -13149.187     -13292.231     -13292.231      276.7284       276.7284       67235.355      67235.355      568.77152      568.77152    
Loop time of 61.1916 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.998 hours/ns, 16.342 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.039     | 61.039     | 61.039     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021342   | 0.021342   | 0.021342   |   0.0 |  0.03
Output  | 4.6247e-05 | 4.6247e-05 | 4.6247e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284544 ave      284544 max      284544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284544
Ave neighs/atom = 71.136
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.774215288952, Press = 1.13129348683851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13149.187     -13149.187     -13292.231     -13292.231      276.7284       276.7284       67235.355      67235.355      568.77152      568.77152    
     37000  -13155.136     -13155.136     -13295.927     -13295.927      272.37076      272.37076      67238.307      67238.307      186.85353      186.85353    
Loop time of 61.1668 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.991 hours/ns, 16.349 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.014     | 61.014     | 61.014     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02138    | 0.02138    | 0.02138    |   0.0 |  0.03
Output  | 5.0215e-05 | 5.0215e-05 | 5.0215e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283890 ave      283890 max      283890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283890
Ave neighs/atom = 70.9725
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.772192594685, Press = 1.08884378835225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13155.136     -13155.136     -13295.927     -13295.927      272.37076      272.37076      67238.307      67238.307      186.85353      186.85353    
     38000  -13151.363     -13151.363     -13291.119     -13291.119      270.36782      270.36782      67275.635      67275.635      139.41854      139.41854    
Loop time of 61.1496 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.986 hours/ns, 16.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.996     | 60.996     | 60.996     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021408   | 0.021408   | 0.021408   |   0.0 |  0.04
Output  | 0.00011477 | 0.00011477 | 0.00011477 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283942 ave      283942 max      283942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283942
Ave neighs/atom = 70.9855
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.780423142828, Press = 0.673575176620682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13151.363     -13151.363     -13291.119     -13291.119      270.36782      270.36782      67275.635      67275.635      139.41854      139.41854    
     39000  -13153.681     -13153.681     -13295.194     -13295.194      273.76678      273.76678      67267.464      67267.464     -72.609275     -72.609275    
Loop time of 61.1527 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.987 hours/ns, 16.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.999     | 60.999     | 60.999     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021577   | 0.021577   | 0.021577   |   0.0 |  0.04
Output  | 4.5836e-05 | 4.5836e-05 | 4.5836e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283450 ave      283450 max      283450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283450
Ave neighs/atom = 70.8625
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.800712157478, Press = 0.277925682461486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13153.681     -13153.681     -13295.194     -13295.194      273.76678      273.76678      67267.464      67267.464     -72.609275     -72.609275    
     40000  -13148.499     -13148.499     -13292.147     -13292.147      277.89562      277.89562      67287.885      67287.885     -79.603416     -79.603416    
Loop time of 61.1773 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.994 hours/ns, 16.346 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.024     | 61.024     | 61.024     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021363   | 0.021363   | 0.021363   |   0.0 |  0.03
Output  | 4.4714e-05 | 4.4714e-05 | 4.4714e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283998 ave      283998 max      283998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283998
Ave neighs/atom = 70.9995
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.80988610295, Press = 0.267484813019121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13148.499     -13148.499     -13292.147     -13292.147      277.89562      277.89562      67287.885      67287.885     -79.603416     -79.603416    
     41000  -13155.963     -13155.963     -13296.464     -13296.464      271.80871      271.80871      67237.571      67237.571      151.2839       151.2839     
Loop time of 61.0111 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.948 hours/ns, 16.390 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.858     | 60.858     | 60.858     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021439   | 0.021439   | 0.021439   |   0.0 |  0.04
Output  | 4.4533e-05 | 4.4533e-05 | 4.4533e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283304 ave      283304 max      283304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283304
Ave neighs/atom = 70.826
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.786178425197, Press = 0.189340330005489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13155.963     -13155.963     -13296.464     -13296.464      271.80871      271.80871      67237.571      67237.571      151.2839       151.2839     
     42000  -13149.339     -13149.339     -13294.219     -13294.219      280.28008      280.28008      67220.074      67220.074      615.62665      615.62665    
Loop time of 61.1145 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.976 hours/ns, 16.363 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.961     | 60.961     | 60.961     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021451   | 0.021451   | 0.021451   |   0.0 |  0.04
Output  | 4.767e-05  | 4.767e-05  | 4.767e-05  |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284206 ave      284206 max      284206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284206
Ave neighs/atom = 71.0515
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.771970359488, Press = 0.0661438358678483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13149.339     -13149.339     -13294.219     -13294.219      280.28008      280.28008      67220.074      67220.074      615.62665      615.62665    
     43000  -13153.258     -13153.258     -13293.906     -13293.906      272.09206      272.09206      67186.579      67186.579      932.30422      932.30422    
Loop time of 61.0523 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.959 hours/ns, 16.379 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.899     | 60.899     | 60.899     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02138    | 0.02138    | 0.02138    |   0.0 |  0.04
Output  | 4.3963e-05 | 4.3963e-05 | 4.3963e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284116 ave      284116 max      284116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284116
Ave neighs/atom = 71.029
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.806362181636, Press = 0.171212490132192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13153.258     -13153.258     -13293.906     -13293.906      272.09206      272.09206      67186.579      67186.579      932.30422      932.30422    
     44000  -13149.2       -13149.2       -13294.472     -13294.472      281.0375       281.0375       67180.814      67180.814      998.54138      998.54138    
Loop time of 61.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.947 hours/ns, 16.391 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.857     | 60.857     | 60.857     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021375   | 0.021375   | 0.021375   |   0.0 |  0.04
Output  | 4.7138e-05 | 4.7138e-05 | 4.7138e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.20
Other   |            | 0.01045    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284324 ave      284324 max      284324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284324
Ave neighs/atom = 71.081
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.813336896066, Press = 0.72888927877184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13149.2       -13149.2       -13294.472     -13294.472      281.0375       281.0375       67180.814      67180.814      998.54138      998.54138    
     45000  -13152.205     -13152.205     -13293.921     -13293.921      274.15816      274.15816      67190.463      67190.463      891.51149      891.51149    
Loop time of 61.0704 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.964 hours/ns, 16.375 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.917     | 60.917     | 60.917     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021496   | 0.021496   | 0.021496   |   0.0 |  0.04
Output  | 4.4644e-05 | 4.4644e-05 | 4.4644e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284376 ave      284376 max      284376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284376
Ave neighs/atom = 71.094
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.858280049592, Press = 0.721179238061232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13152.205     -13152.205     -13293.921     -13293.921      274.15816      274.15816      67190.463      67190.463      891.51149      891.51149    
     46000  -13149.419     -13149.419     -13291.335     -13291.335      274.54482      274.54482      67270.525      67270.525      229.4052       229.4052     
Loop time of 61.106 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.974 hours/ns, 16.365 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.953     | 60.953     | 60.953     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021478   | 0.021478   | 0.021478   |   0.0 |  0.04
Output  | 3.8152e-05 | 3.8152e-05 | 3.8152e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       284346 ave      284346 max      284346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 284346
Ave neighs/atom = 71.0865
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.859102633044, Press = 0.566742898956241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13149.419     -13149.419     -13291.335     -13291.335      274.54482      274.54482      67270.525      67270.525      229.4052       229.4052     
     47000  -13150.877     -13150.877     -13292.5       -13292.5        273.979        273.979        67274.909      67274.909      49.835176      49.835176    
Loop time of 61.1595 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.989 hours/ns, 16.351 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.006     | 61.006     | 61.006     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021369   | 0.021369   | 0.021369   |   0.0 |  0.03
Output  | 4.0867e-05 | 4.0867e-05 | 4.0867e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283714 ave      283714 max      283714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283714
Ave neighs/atom = 70.9285
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.926398081179, Press = 0.47829056860378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13150.877     -13150.877     -13292.5       -13292.5        273.979        273.979        67274.909      67274.909      49.835176      49.835176    
     48000  -13155.336     -13155.336     -13295.708     -13295.708      271.55941      271.55941      67276.513      67276.513     -192.11522     -192.11522    
Loop time of 61.1124 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.976 hours/ns, 16.363 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.959     | 60.959     | 60.959     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021477   | 0.021477   | 0.021477   |   0.0 |  0.04
Output  | 3.9304e-05 | 3.9304e-05 | 3.9304e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.20
Other   |            | 0.01045    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283798 ave      283798 max      283798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283798
Ave neighs/atom = 70.9495
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.921071399329, Press = 0.629754991275261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13155.336     -13155.336     -13295.708     -13295.708      271.55941      271.55941      67276.513      67276.513     -192.11522     -192.11522    
     49000  -13146.342     -13146.342     -13290         -13290          277.91698      277.91698      67342.336      67342.336     -473.84758     -473.84758    
Loop time of 61.0377 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.955 hours/ns, 16.383 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.884     | 60.884     | 60.884     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021355   | 0.021355   | 0.021355   |   0.0 |  0.03
Output  | 3.3813e-05 | 3.3813e-05 | 3.3813e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283566 ave      283566 max      283566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283566
Ave neighs/atom = 70.8915
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.932170639311, Press = 0.826783249953099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13146.342     -13146.342     -13290         -13290          277.91698      277.91698      67342.336      67342.336     -473.84758     -473.84758    
     50000  -13154.913     -13154.913     -13296.318     -13296.318      273.55705      273.55705      67359.041      67359.041     -1141.9776     -1141.9776    
Loop time of 61.1093 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.975 hours/ns, 16.364 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.956     | 60.956     | 60.956     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021344   | 0.021344   | 0.021344   |   0.0 |  0.03
Output  | 3.6118e-05 | 3.6118e-05 | 3.6118e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.20
Other   |            | 0.01042    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283052 ave      283052 max      283052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283052
Ave neighs/atom = 70.763
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.957973956108, Press = 1.02332918889548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13154.913     -13154.913     -13296.318     -13296.318      273.55705      273.55705      67359.041      67359.041     -1141.9776     -1141.9776    
     51000  -13148.484     -13148.484     -13294.441     -13294.441      282.36326      282.36326      67367.682      67367.682     -1043.5737     -1043.5737    
Loop time of 61.0195 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.950 hours/ns, 16.388 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.866     | 60.866     | 60.866     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021357   | 0.021357   | 0.021357   |   0.0 |  0.03
Output  | 3.5808e-05 | 3.5808e-05 | 3.5808e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.20
Other   |            | 0.01045    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       282782 ave      282782 max      282782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 282782
Ave neighs/atom = 70.6955
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.988651552625, Press = 0.301027799153267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13148.484     -13148.484     -13294.441     -13294.441      282.36326      282.36326      67367.682      67367.682     -1043.5737     -1043.5737    
     52000  -13153.925     -13153.925     -13294.833     -13294.833      272.5955       272.5955       67310.915      67310.915     -491.34193     -491.34193    
Loop time of 61.0442 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.957 hours/ns, 16.382 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.891     | 60.891     | 60.891     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02129    | 0.02129    | 0.02129    |   0.0 |  0.03
Output  | 3.6749e-05 | 3.6749e-05 | 3.6749e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       283108 ave      283108 max      283108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 283108
Ave neighs/atom = 70.777
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
67274.174067961

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0