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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133157 36.133157 36.133157)
  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 (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6305927869 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_353393547686_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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47175.631      47175.631      3196.8187      3196.8187    
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2832     -1401.2832    
Loop time of 267.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.323 ns/day, 74.237 hours/ns, 3.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.32     | 266.32     | 266.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1472     | 0.1472     | 0.1472     |   0.0 |  0.06
Output  | 0.00027462 | 0.00027462 | 0.00027462 |   0.0 |  0.00
Modify  | 0.69312    | 0.69312    | 0.69312    |   0.0 |  0.26
Other   |            | 0.09897    |            |       |  0.04

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

Total # of neighbors = 344000
Ave neighs/atom = 86
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2832     -1401.2832    
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88556      275.88556      47875.069      47875.069     -480.35182     -480.35182    
Loop time of 284.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.034 hours/ns, 3.515 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.54     | 283.54     | 283.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1533     | 0.1533     | 0.1533     |   0.0 |  0.05
Output  | 0.00022661 | 0.00022661 | 0.00022661 |   0.0 |  0.00
Modify  | 0.73218    | 0.73218    | 0.73218    |   0.0 |  0.26
Other   |            | 0.102      |            |       |  0.04

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

Total # of neighbors = 343568
Ave neighs/atom = 85.892
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88556      275.88556      47875.069      47875.069     -480.35182     -480.35182    
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83332     -639.83332    
Loop time of 289.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.488 hours/ns, 3.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.74     | 288.74     | 288.74     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15673    | 0.15673    | 0.15673    |   0.0 |  0.05
Output  | 0.00028134 | 0.00028134 | 0.00028134 |   0.0 |  0.00
Modify  | 0.75382    | 0.75382    | 0.75382    |   0.0 |  0.26
Other   |            | 0.104      |            |       |  0.04

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

Total # of neighbors = 343690
Ave neighs/atom = 85.9225
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83332     -639.83332    
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44925     -856.44925    
Loop time of 283.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.679 hours/ns, 3.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.25     | 282.25     | 282.25     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15375    | 0.15375    | 0.15375    |   0.0 |  0.05
Output  | 0.00023277 | 0.00023277 | 0.00023277 |   0.0 |  0.00
Modify  | 0.73698    | 0.73698    | 0.73698    |   0.0 |  0.26
Other   |            | 0.102      |            |       |  0.04

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

Total # of neighbors = 343756
Ave neighs/atom = 85.939
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44925     -856.44925    
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31182      265.31182      47860.951      47860.951      513.55667      513.55667    
Loop time of 282.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.433 hours/ns, 3.542 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 281.37     | 281.37     | 281.37     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15388    | 0.15388    | 0.15388    |   0.0 |  0.05
Output  | 0.00023822 | 0.00023822 | 0.00023822 |   0.0 |  0.00
Modify  | 0.73067    | 0.73067    | 0.73067    |   0.0 |  0.26
Other   |            | 0.1024     |            |       |  0.04

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

Total # of neighbors = 343672
Ave neighs/atom = 85.918
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.452431287086, Press = 727.424001687052
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31182      265.31182      47860.951      47860.951      513.55667      513.55667    
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.204       1491.204     
Loop time of 280.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.308 ns/day, 77.931 hours/ns, 3.564 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 279.55     | 279.55     | 279.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15163    | 0.15163    | 0.15163    |   0.0 |  0.05
Output  | 0.00018862 | 0.00018862 | 0.00018862 |   0.0 |  0.00
Modify  | 0.75073    | 0.75073    | 0.75073    |   0.0 |  0.27
Other   |            | 0.1015     |            |       |  0.04

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

Total # of neighbors = 343712
Ave neighs/atom = 85.928
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.610072039201, Press = 17.790371009979
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.204       1491.204     
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1849     -1036.1849    
Loop time of 283.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.802 hours/ns, 3.525 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.67     | 282.67     | 282.67     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15417    | 0.15417    | 0.15417    |   0.0 |  0.05
Output  | 0.0001874  | 0.0001874  | 0.0001874  |   0.0 |  0.00
Modify  | 0.76108    | 0.76108    | 0.76108    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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

Total # of neighbors = 343826
Ave neighs/atom = 85.9565
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.012114513626, Press = -4.48327468305879
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1849     -1036.1849    
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.7188      -711.7188     
Loop time of 285.734 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.371 hours/ns, 3.500 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.71     | 284.71     | 284.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15489    | 0.15489    | 0.15489    |   0.0 |  0.05
Output  | 0.00024111 | 0.00024111 | 0.00024111 |   0.0 |  0.00
Modify  | 0.76907    | 0.76907    | 0.76907    |   0.0 |  0.27
Other   |            | 0.1019     |            |       |  0.04

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

Total # of neighbors = 343610
Ave neighs/atom = 85.9025
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.088072357529, Press = 19.9536784160563
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.7188      -711.7188     
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41891      273.41891      47847.43       47847.43       1351.3929      1351.3929    
Loop time of 289.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.426 hours/ns, 3.454 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.48     | 288.48     | 288.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1569     | 0.1569     | 0.1569     |   0.0 |  0.05
Output  | 0.00019019 | 0.00019019 | 0.00019019 |   0.0 |  0.00
Modify  | 0.79075    | 0.79075    | 0.79075    |   0.0 |  0.27
Other   |            | 0.1034     |            |       |  0.04

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

Total # of neighbors = 343658
Ave neighs/atom = 85.9145
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.383463877217, Press = 12.2281084969827
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41891      273.41891      47847.43       47847.43       1351.3929      1351.3929    
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42844      394.42844    
Loop time of 286.657 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.627 hours/ns, 3.488 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.63     | 285.63     | 285.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15518    | 0.15518    | 0.15518    |   0.0 |  0.05
Output  | 0.00018919 | 0.00018919 | 0.00018919 |   0.0 |  0.00
Modify  | 0.77209    | 0.77209    | 0.77209    |   0.0 |  0.27
Other   |            | 0.1033     |            |       |  0.04

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

Total # of neighbors = 343738
Ave neighs/atom = 85.9345
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.298219098017, Press = 4.11257919181163
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42844      394.42844    
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89318      266.89318      47903.178      47903.178     -896.69849     -896.69849    
Loop time of 287.568 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.880 hours/ns, 3.477 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.54     | 286.54     | 286.54     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15597    | 0.15597    | 0.15597    |   0.0 |  0.05
Output  | 0.00018699 | 0.00018699 | 0.00018699 |   0.0 |  0.00
Modify  | 0.77386    | 0.77386    | 0.77386    |   0.0 |  0.27
Other   |            | 0.1022     |            |       |  0.04

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

Total # of neighbors = 343720
Ave neighs/atom = 85.93
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.181711567828, Press = 2.01454353005512
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89318      266.89318      47903.178      47903.178     -896.69849     -896.69849    
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45384      272.45384      47887.829      47887.829     -429.56877     -429.56877    
Loop time of 286.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.526 hours/ns, 3.493 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.26     | 285.26     | 285.26     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15421    | 0.15421    | 0.15421    |   0.0 |  0.05
Output  | 0.0001875  | 0.0001875  | 0.0001875  |   0.0 |  0.00
Modify  | 0.77405    | 0.77405    | 0.77405    |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  0.04

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

Total # of neighbors = 343706
Ave neighs/atom = 85.9265
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.921833684026, Press = 11.4618975849587
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45384      272.45384      47887.829      47887.829     -429.56877     -429.56877    
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74982      273.74982      47798.836      47798.836      2059.7704      2059.7704    
Loop time of 286.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.478 hours/ns, 3.495 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.09     | 285.09     | 285.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15443    | 0.15443    | 0.15443    |   0.0 |  0.05
Output  | 0.00018866 | 0.00018866 | 0.00018866 |   0.0 |  0.00
Modify  | 0.776      | 0.776      | 0.776      |   0.0 |  0.27
Other   |            | 0.1035     |            |       |  0.04

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

Total # of neighbors = 343642
Ave neighs/atom = 85.9105
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.939827904045, Press = 2.55596846407452
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74982      273.74982      47798.836      47798.836      2059.7704      2059.7704    
     14000  -13872.136     -13872.136     -14013.703     -14013.703      273.87137      273.87137      47913.946      47913.946     -537.58094     -537.58094    
Loop time of 291.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.933 hours/ns, 3.432 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 290.31     | 290.31     | 290.31     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1567     | 0.1567     | 0.1567     |   0.0 |  0.05
Output  | 0.00023732 | 0.00023732 | 0.00023732 |   0.0 |  0.00
Modify  | 0.78679    | 0.78679    | 0.78679    |   0.0 |  0.27
Other   |            | 0.104      |            |       |  0.04

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

Total # of neighbors = 343808
Ave neighs/atom = 85.952
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.053930213056, Press = 0.995008292020519
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13872.136     -13872.136     -14013.703     -14013.703      273.87137      273.87137      47913.946      47913.946     -537.58094     -537.58094    
     15000  -13879.085     -13879.085     -14019.722     -14019.722      272.07213      272.07213      47872.852      47872.852     -92.602276     -92.602276    
Loop time of 285.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.339 hours/ns, 3.501 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.6      | 284.6      | 284.6      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15509    | 0.15509    | 0.15509    |   0.0 |  0.05
Output  | 0.00018848 | 0.00018848 | 0.00018848 |   0.0 |  0.00
Modify  | 0.76663    | 0.76663    | 0.76663    |   0.0 |  0.27
Other   |            | 0.1019     |            |       |  0.04

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

Total # of neighbors = 343788
Ave neighs/atom = 85.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 = 273.187715971198, Press = 3.89370543906118
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13879.085     -13879.085     -14019.722     -14019.722      272.07213      272.07213      47872.852      47872.852     -92.602276     -92.602276    
     16000  -13882.539     -13882.539     -14022.508     -14022.508      270.77963      270.77963      47843.484      47843.484      495.99007      495.99007    
Loop time of 287.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.988 hours/ns, 3.473 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.92     | 286.92     | 286.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15571    | 0.15571    | 0.15571    |   0.0 |  0.05
Output  | 0.00023839 | 0.00023839 | 0.00023839 |   0.0 |  0.00
Modify  | 0.7787     | 0.7787     | 0.7787     |   0.0 |  0.27
Other   |            | 0.1042     |            |       |  0.04

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

Total # of neighbors = 343722
Ave neighs/atom = 85.9305
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.159060835708, Press = 3.81796288775548
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13882.539     -13882.539     -14022.508     -14022.508      270.77963      270.77963      47843.484      47843.484      495.99007      495.99007    
     17000  -13874.853     -13874.853     -14016.18      -14016.18       273.40679      273.40679      47860.764      47860.764      749.20264      749.20264    
Loop time of 289.749 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.486 hours/ns, 3.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.7      | 288.7      | 288.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15667    | 0.15667    | 0.15667    |   0.0 |  0.05
Output  | 0.00018947 | 0.00018947 | 0.00018947 |   0.0 |  0.00
Modify  | 0.79032    | 0.79032    | 0.79032    |   0.0 |  0.27
Other   |            | 0.1033     |            |       |  0.04

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

Total # of neighbors = 343708
Ave neighs/atom = 85.927
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.066305000991, Press = 1.52336407427009
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13874.853     -13874.853     -14016.18      -14016.18       273.40679      273.40679      47860.764      47860.764      749.20264      749.20264    
     18000  -13878.764     -13878.764     -14019.439     -14019.439      272.14595      272.14595      47906.717      47906.717     -1051.9313     -1051.9313    
Loop time of 287.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.798 hours/ns, 3.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.25     | 286.25     | 286.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15422    | 0.15422    | 0.15422    |   0.0 |  0.05
Output  | 0.00024864 | 0.00024864 | 0.00024864 |   0.0 |  0.00
Modify  | 0.76858    | 0.76858    | 0.76858    |   0.0 |  0.27
Other   |            | 0.1017     |            |       |  0.04

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

Total # of neighbors = 343722
Ave neighs/atom = 85.9305
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.203539886801, Press = 0.333787239188638
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13878.764     -13878.764     -14019.439     -14019.439      272.14595      272.14595      47906.717      47906.717     -1051.9313     -1051.9313    
     19000  -13872.589     -13872.589     -14012.888     -14012.888      271.41863      271.41863      47911.28       47911.28      -421.46919     -421.46919    
Loop time of 290.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.647 hours/ns, 3.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 289.27     | 289.27     | 289.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15792    | 0.15792    | 0.15792    |   0.0 |  0.05
Output  | 0.00024311 | 0.00024311 | 0.00024311 |   0.0 |  0.00
Modify  | 0.79453    | 0.79453    | 0.79453    |   0.0 |  0.27
Other   |            | 0.1047     |            |       |  0.04

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

Total # of neighbors = 343730
Ave neighs/atom = 85.9325
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.272238280556, Press = 4.28065061282094
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13872.589     -13872.589     -14012.888     -14012.888      271.41863      271.41863      47911.28       47911.28      -421.46919     -421.46919    
     20000  -13877.086     -13877.086     -14020.13      -14020.13       276.72762      276.72762      47808.919      47808.919      1809.0131      1809.0131    
Loop time of 289.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.299 ns/day, 80.327 hours/ns, 3.458 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.13     | 288.13     | 288.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15793    | 0.15793    | 0.15793    |   0.0 |  0.05
Output  | 0.00019079 | 0.00019079 | 0.00019079 |   0.0 |  0.00
Modify  | 0.78548    | 0.78548    | 0.78548    |   0.0 |  0.27
Other   |            | 0.103      |            |       |  0.04

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

Total # of neighbors = 343668
Ave neighs/atom = 85.917
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.270222013251, Press = 2.71432755447776
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13877.086     -13877.086     -14020.13      -14020.13       276.72762      276.72762      47808.919      47808.919      1809.0131      1809.0131    
     21000  -13878.065     -13878.065     -14019.993     -14019.993      274.56775      274.56775      47879.458      47879.458     -138.88877     -138.88877    
Loop time of 280.592 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.308 ns/day, 77.942 hours/ns, 3.564 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 279.59     | 279.59     | 279.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15178    | 0.15178    | 0.15178    |   0.0 |  0.05
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.74854    | 0.74854    | 0.74854    |   0.0 |  0.27
Other   |            | 0.1012     |            |       |  0.04

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

Total # of neighbors = 343750
Ave neighs/atom = 85.9375
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.245168773881, Press = -1.78983725196754
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13878.065     -13878.065     -14019.993     -14019.993      274.56775      274.56775      47879.458      47879.458     -138.88877     -138.88877    
     22000  -13876.888     -13876.888     -14017.915     -14017.915      272.82507      272.82507      47937.422      47937.422     -1723.7925     -1723.7925    
Loop time of 284.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.051 hours/ns, 3.514 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.56     | 283.56     | 283.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15474    | 0.15474    | 0.15474    |   0.0 |  0.05
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.76655    | 0.76655    | 0.76655    |   0.0 |  0.27
Other   |            | 0.1018     |            |       |  0.04

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

Total # of neighbors = 343702
Ave neighs/atom = 85.9255
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.286037241619, Press = 2.50248992506113
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13876.888     -13876.888     -14017.915     -14017.915      272.82507      272.82507      47937.422      47937.422     -1723.7925     -1723.7925    
     23000  -13873.107     -13873.107     -14014.304     -14014.304      273.15454      273.15454      47865.51       47865.51       849.57162      849.57162    
Loop time of 282.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.554 hours/ns, 3.536 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 281.79     | 281.79     | 281.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.05
Output  | 0.00018851 | 0.00018851 | 0.00018851 |   0.0 |  0.00
Modify  | 0.75028    | 0.75028    | 0.75028    |   0.0 |  0.27
Other   |            | 0.1014     |            |       |  0.04

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

Total # of neighbors = 343668
Ave neighs/atom = 85.917
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.285287042427, Press = 2.97889866444816
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13873.107     -13873.107     -14014.304     -14014.304      273.15454      273.15454      47865.51       47865.51       849.57162      849.57162    
     24000  -13878.763     -13878.763     -14020.133     -14020.133      273.48833      273.48833      47857.272      47857.272      432.35173      432.35173    
Loop time of 285.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.383 hours/ns, 3.499 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.74     | 284.74     | 284.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15527    | 0.15527    | 0.15527    |   0.0 |  0.05
Output  | 0.00019371 | 0.00019371 | 0.00019371 |   0.0 |  0.00
Modify  | 0.78087    | 0.78087    | 0.78087    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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

Total # of neighbors = 343784
Ave neighs/atom = 85.946
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.385396420145, Press = 1.03091662078251
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13878.763     -13878.763     -14020.133     -14020.133      273.48833      273.48833      47857.272      47857.272      432.35173      432.35173    
     25000  -13877.556     -13877.556     -14016.494     -14016.494      268.78522      268.78522      47901.712      47901.712     -484.32847     -484.32847    
Loop time of 284.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.156 hours/ns, 3.509 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.94     | 283.94     | 283.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15426    | 0.15426    | 0.15426    |   0.0 |  0.05
Output  | 0.00019112 | 0.00019112 | 0.00019112 |   0.0 |  0.00
Modify  | 0.76446    | 0.76446    | 0.76446    |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  0.04

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

Total # of neighbors = 343756
Ave neighs/atom = 85.939
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.383729335024, Press = 0.897451352152771
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13877.556     -13877.556     -14016.494     -14016.494      268.78522      268.78522      47901.712      47901.712     -484.32847     -484.32847    
     26000  -13880.497     -13880.497     -14018.85      -14018.85       267.65266      267.65266      47879.242      47879.242     -71.410041     -71.410041    
Loop time of 288.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 80.016 hours/ns, 3.472 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.02     | 287.02     | 287.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15586    | 0.15586    | 0.15586    |   0.0 |  0.05
Output  | 0.00019027 | 0.00019027 | 0.00019027 |   0.0 |  0.00
Modify  | 0.78082    | 0.78082    | 0.78082    |   0.0 |  0.27
Other   |            | 0.1031     |            |       |  0.04

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

Total # of neighbors = 343620
Ave neighs/atom = 85.905
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.367577911838, Press = 4.12586380231392
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13880.497     -13880.497     -14018.85      -14018.85       267.65266      267.65266      47879.242      47879.242     -71.410041     -71.410041    
     27000  -13875.776     -13875.776     -14015.86      -14015.86       271.00215      271.00215      47791.272      47791.272      2770.8038      2770.8038    
Loop time of 283.705 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.807 hours/ns, 3.525 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.69     | 282.69     | 282.69     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15338    | 0.15338    | 0.15338    |   0.0 |  0.05
Output  | 0.0001911  | 0.0001911  | 0.0001911  |   0.0 |  0.00
Modify  | 0.76127    | 0.76127    | 0.76127    |   0.0 |  0.27
Other   |            | 0.1019     |            |       |  0.04

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

Total # of neighbors = 343768
Ave neighs/atom = 85.942
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.309070399456, Press = 1.43300412414978
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13875.776     -13875.776     -14015.86      -14015.86       271.00215      271.00215      47791.272      47791.272      2770.8038      2770.8038    
     28000  -13882.102     -13882.102     -14020.31      -14020.31       267.37358      267.37358      47887.043      47887.043     -453.24449     -453.24449    
Loop time of 287.419 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.839 hours/ns, 3.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.38     | 286.38     | 286.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15547    | 0.15547    | 0.15547    |   0.0 |  0.05
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.77933    | 0.77933    | 0.77933    |   0.0 |  0.27
Other   |            | 0.1034     |            |       |  0.04

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

Total # of neighbors = 343818
Ave neighs/atom = 85.9545
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.250638779878, Press = -0.649479342398968
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13882.102     -13882.102     -14020.31      -14020.31       267.37358      267.37358      47887.043      47887.043     -453.24449     -453.24449    
     29000  -13875.991     -13875.991     -14017.667     -14017.667      274.08226      274.08226      47901.999      47901.999     -644.05548     -644.05548    
Loop time of 281.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.163 hours/ns, 3.554 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 280.38     | 280.38     | 280.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.05
Output  | 0.00030473 | 0.00030473 | 0.00030473 |   0.0 |  0.00
Modify  | 0.7535     | 0.7535     | 0.7535     |   0.0 |  0.27
Other   |            | 0.1022     |            |       |  0.04

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

Total # of neighbors = 343704
Ave neighs/atom = 85.926
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.283204890984, Press = 2.15409617895587
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13875.991     -13875.991     -14017.667     -14017.667      274.08226      274.08226      47901.999      47901.999     -644.05548     -644.05548    
     30000  -13876.909     -13876.909     -14018.401     -14018.401      273.7262       273.7262       47848.159      47848.159      847.89668      847.89668    
Loop time of 279.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.310 ns/day, 77.508 hours/ns, 3.584 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 278.03     | 278.03     | 278.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15227    | 0.15227    | 0.15227    |   0.0 |  0.05
Output  | 0.00018985 | 0.00018985 | 0.00018985 |   0.0 |  0.00
Modify  | 0.74894    | 0.74894    | 0.74894    |   0.0 |  0.27
Other   |            | 0.1011     |            |       |  0.04

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

Total # of neighbors = 343710
Ave neighs/atom = 85.9275
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.287638731585, Press = 1.65544015931042
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13876.909     -13876.909     -14018.401     -14018.401      273.7262       273.7262       47848.159      47848.159      847.89668      847.89668    
     31000  -13877.174     -13877.174     -14016.305     -14016.305      269.15847      269.15847      47860.423      47860.423      728.70937      728.70937    
Loop time of 284.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.035 hours/ns, 3.515 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.51     | 283.51     | 283.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15265    | 0.15265    | 0.15265    |   0.0 |  0.05
Output  | 0.00024286 | 0.00024286 | 0.00024286 |   0.0 |  0.00
Modify  | 0.75818    | 0.75818    | 0.75818    |   0.0 |  0.27
Other   |            | 0.1017     |            |       |  0.04

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

Total # of neighbors = 343746
Ave neighs/atom = 85.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 = 273.360836371833, Press = 0.673787333133185
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13877.174     -13877.174     -14016.305     -14016.305      269.15847      269.15847      47860.423      47860.423      728.70937      728.70937    
     32000  -13874.625     -13874.625     -14014.849     -14014.849      271.27341      271.27341      47927.722      47927.722     -1099.8373     -1099.8373    
Loop time of 289.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.504 hours/ns, 3.450 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.77     | 288.77     | 288.77     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.05
Output  | 0.00018917 | 0.00018917 | 0.00018917 |   0.0 |  0.00
Modify  | 0.78563    | 0.78563    | 0.78563    |   0.0 |  0.27
Other   |            | 0.1039     |            |       |  0.04

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

Total # of neighbors = 343720
Ave neighs/atom = 85.93
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.365211913073, Press = -0.00443486122045832
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13874.625     -13874.625     -14014.849     -14014.849      271.27341      271.27341      47927.722      47927.722     -1099.8373     -1099.8373    
     33000  -13879.894     -13879.894     -14019.68      -14019.68       270.42677      270.42677      47889.594      47889.594     -445.07359     -445.07359    
Loop time of 290.504 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.696 hours/ns, 3.442 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 289.47     | 289.47     | 289.47     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15614    | 0.15614    | 0.15614    |   0.0 |  0.05
Output  | 0.00019107 | 0.00019107 | 0.00019107 |   0.0 |  0.00
Modify  | 0.7786     | 0.7786     | 0.7786     |   0.0 |  0.27
Other   |            | 0.1024     |            |       |  0.04

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

Total # of neighbors = 343632
Ave neighs/atom = 85.908
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.415206516952, Press = 2.80259131552242
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13879.894     -13879.894     -14019.68      -14019.68       270.42677      270.42677      47889.594      47889.594     -445.07359     -445.07359    
     34000  -13870.909     -13870.909     -14016.507     -14016.507      281.67029      281.67029      47856.914      47856.914      964.15896      964.15896    
Loop time of 292.636 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.295 ns/day, 81.288 hours/ns, 3.417 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 291.6      | 291.6      | 291.6      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15623    | 0.15623    | 0.15623    |   0.0 |  0.05
Output  | 0.00018915 | 0.00018915 | 0.00018915 |   0.0 |  0.00
Modify  | 0.77886    | 0.77886    | 0.77886    |   0.0 |  0.27
Other   |            | 0.1037     |            |       |  0.04

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

Total # of neighbors = 343702
Ave neighs/atom = 85.9255
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.446132460843, Press = 1.26885279704028
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13870.909     -13870.909     -14016.507     -14016.507      281.67029      281.67029      47856.914      47856.914      964.15896      964.15896    
     35000  -13879.051     -13879.051     -14020.474     -14020.474      273.59279      273.59279      47861.114      47861.114      288.14979      288.14979    
Loop time of 286.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.532 hours/ns, 3.493 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.29     | 285.29     | 285.29     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15488    | 0.15488    | 0.15488    |   0.0 |  0.05
Output  | 0.00018913 | 0.00018913 | 0.00018913 |   0.0 |  0.00
Modify  | 0.76974    | 0.76974    | 0.76974    |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  0.04

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

Total # of neighbors = 343758
Ave neighs/atom = 85.9395
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.474769697197, Press = 0.304595115770726
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13879.051     -13879.051     -14020.474     -14020.474      273.59279      273.59279      47861.114      47861.114      288.14979      288.14979    
     36000  -13874.04      -13874.04      -14015.51      -14015.51       273.68492      273.68492      47921.491      47921.491     -1003.9953     -1003.9953    
Loop time of 285.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.263 hours/ns, 3.505 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.32     | 284.32     | 284.32     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15317    | 0.15317    | 0.15317    |   0.0 |  0.05
Output  | 0.00023507 | 0.00023507 | 0.00023507 |   0.0 |  0.00
Modify  | 0.76555    | 0.76555    | 0.76555    |   0.0 |  0.27
Other   |            | 0.1031     |            |       |  0.04

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

Total # of neighbors = 343750
Ave neighs/atom = 85.9375
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.509900816134, Press = 0.394929493535776
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13874.04      -13874.04      -14015.51      -14015.51       273.68492      273.68492      47921.491      47921.491     -1003.9953     -1003.9953    
     37000  -13880.878     -13880.878     -14017.926     -14017.926      265.12889      265.12889      47897.776      47897.776     -658.5167      -658.5167     
Loop time of 287.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.903 hours/ns, 3.476 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.6      | 286.6      | 286.6      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15614    | 0.15614    | 0.15614    |   0.0 |  0.05
Output  | 0.00022479 | 0.00022479 | 0.00022479 |   0.0 |  0.00
Modify  | 0.789      | 0.789      | 0.789      |   0.0 |  0.27
Other   |            | 0.1047     |            |       |  0.04

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

Total # of neighbors = 343628
Ave neighs/atom = 85.907
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.499676333379, Press = 2.75998008887162
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13880.878     -13880.878     -14017.926     -14017.926      265.12889      265.12889      47897.776      47897.776     -658.5167      -658.5167     
     38000  -13876.585     -13876.585     -14019.885     -14019.885      277.22372      277.22372      47806.391      47806.391      1955.6254      1955.6254    
Loop time of 287.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.929 hours/ns, 3.475 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.71     | 286.71     | 286.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.05
Output  | 0.0002884  | 0.0002884  | 0.0002884  |   0.0 |  0.00
Modify  | 0.77444    | 0.77444    | 0.77444    |   0.0 |  0.27
Other   |            | 0.1035     |            |       |  0.04

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

Total # of neighbors = 343758
Ave neighs/atom = 85.9395
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.456064513186, Press = 1.07808270238372
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13876.585     -13876.585     -14019.885     -14019.885      277.22372      277.22372      47806.391      47806.391      1955.6254      1955.6254    
     39000  -13878.876     -13878.876     -14019.633     -14019.633      272.30428      272.30428      47894.413      47894.413     -658.12503     -658.12503    
Loop time of 290.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.736 hours/ns, 3.441 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 289.59     | 289.59     | 289.59     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15761    | 0.15761    | 0.15761    |   0.0 |  0.05
Output  | 0.00019243 | 0.00019243 | 0.00019243 |   0.0 |  0.00
Modify  | 0.79925    | 0.79925    | 0.79925    |   0.0 |  0.27
Other   |            | 0.105      |            |       |  0.04

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

Total # of neighbors = 343766
Ave neighs/atom = 85.9415
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.450270067256, Press = 0.610505689027513
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13878.876     -13878.876     -14019.633     -14019.633      272.30428      272.30428      47894.413      47894.413     -658.12503     -658.12503    
     40000  -13874.146     -13874.146     -14015.765     -14015.765      273.97109      273.97109      47894.254      47894.254     -177.95875     -177.95875    
Loop time of 292.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.295 ns/day, 81.371 hours/ns, 3.414 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 291.88     | 291.88     | 291.88     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15833    | 0.15833    | 0.15833    |   0.0 |  0.05
Output  | 0.00024136 | 0.00024136 | 0.00024136 |   0.0 |  0.00
Modify  | 0.79589    | 0.79589    | 0.79589    |   0.0 |  0.27
Other   |            | 0.1045     |            |       |  0.04

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

Total # of neighbors = 343782
Ave neighs/atom = 85.9455
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.470378858146, Press = 1.46541427165007
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13874.146     -13874.146     -14015.765     -14015.765      273.97109      273.97109      47894.254      47894.254     -177.95875     -177.95875    
     41000  -13877.952     -13877.952     -14020.253     -14020.253      275.29242      275.29242      47820.661      47820.661      1415.6671      1415.6671    
Loop time of 289.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.299 ns/day, 80.284 hours/ns, 3.460 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.97     | 287.97     | 287.97     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15653    | 0.15653    | 0.15653    |   0.0 |  0.05
Output  | 0.00019041 | 0.00019041 | 0.00019041 |   0.0 |  0.00
Modify  | 0.79422    | 0.79422    | 0.79422    |   0.0 |  0.27
Other   |            | 0.1049     |            |       |  0.04

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

Total # of neighbors = 343702
Ave neighs/atom = 85.9255
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.458252727031, Press = 1.2836629437546
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13877.952     -13877.952     -14020.253     -14020.253      275.29242      275.29242      47820.661      47820.661      1415.6671      1415.6671    
     42000  -13876.101     -13876.101     -14015.691     -14015.691      270.0477       270.0477       47876.966      47876.966      316.47061      316.47061    
Loop time of 288.352 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 80.098 hours/ns, 3.468 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.31     | 287.31     | 287.31     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15551    | 0.15551    | 0.15551    |   0.0 |  0.05
Output  | 0.00024204 | 0.00024204 | 0.00024204 |   0.0 |  0.00
Modify  | 0.77993    | 0.77993    | 0.77993    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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

Total # of neighbors = 343760
Ave neighs/atom = 85.94
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.419385056646, Press = -1.46210791061916
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13876.101     -13876.101     -14015.691     -14015.691      270.0477       270.0477       47876.966      47876.966      316.47061      316.47061    
     43000  -13879.491     -13879.491     -14016.603     -14016.603      265.25311      265.25311      47948.651      47948.651     -1867.2388     -1867.2388    
Loop time of 287.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.746 hours/ns, 3.483 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.07     | 286.07     | 286.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1543     | 0.1543     | 0.1543     |   0.0 |  0.05
Output  | 0.00030507 | 0.00030507 | 0.00030507 |   0.0 |  0.00
Modify  | 0.76398    | 0.76398    | 0.76398    |   0.0 |  0.27
Other   |            | 0.1022     |            |       |  0.04

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

Total # of neighbors = 343694
Ave neighs/atom = 85.9235
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.37340114559, Press = 1.49655091955055
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13879.491     -13879.491     -14016.603     -14016.603      265.25311      265.25311      47948.651      47948.651     -1867.2388     -1867.2388    
     44000  -13878.924     -13878.924     -14021.584     -14021.584      275.98568      275.98568      47846.831      47846.831      645.60607      645.60607    
Loop time of 289.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.470 hours/ns, 3.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.64     | 288.64     | 288.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15641    | 0.15641    | 0.15641    |   0.0 |  0.05
Output  | 0.00024218 | 0.00024218 | 0.00024218 |   0.0 |  0.00
Modify  | 0.79563    | 0.79563    | 0.79563    |   0.0 |  0.27
Other   |            | 0.1046     |            |       |  0.04

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

Total # of neighbors = 343602
Ave neighs/atom = 85.9005
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.356434250103, Press = 1.54481517295033
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13878.924     -13878.924     -14021.584     -14021.584      275.98568      275.98568      47846.831      47846.831      645.60607      645.60607    
     45000  -13875.002     -13875.002     -14018.803     -14018.803      278.19276      278.19276      47864.55       47864.55       396.73294      396.73294    
Loop time of 289.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.299 ns/day, 80.353 hours/ns, 3.457 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.22     | 288.22     | 288.22     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15859    | 0.15859    | 0.15859    |   0.0 |  0.05
Output  | 0.0012222  | 0.0012222  | 0.0012222  |   0.0 |  0.00
Modify  | 0.78902    | 0.78902    | 0.78902    |   0.0 |  0.27
Other   |            | 0.1039     |            |       |  0.04

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

Total # of neighbors = 343814
Ave neighs/atom = 85.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 = 273.346729143254, Press = 0.532952104815816
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13875.002     -13875.002     -14018.803     -14018.803      278.19276      278.19276      47864.55       47864.55       396.73294      396.73294    
     46000  -13880.848     -13880.848     -14021.512     -14021.512      272.12578      272.12578      47906.898      47906.898     -1214.6907     -1214.6907    
Loop time of 288.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 80.099 hours/ns, 3.468 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.32     | 287.32     | 287.32     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15527    | 0.15527    | 0.15527    |   0.0 |  0.05
Output  | 0.00019014 | 0.00019014 | 0.00019014 |   0.0 |  0.00
Modify  | 0.78107    | 0.78107    | 0.78107    |   0.0 |  0.27
Other   |            | 0.1032     |            |       |  0.04

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

Total # of neighbors = 343722
Ave neighs/atom = 85.9305
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.359366828317, Press = 0.236497469753992
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13880.848     -13880.848     -14021.512     -14021.512      272.12578      272.12578      47906.898      47906.898     -1214.6907     -1214.6907    
     47000  -13873.626     -13873.626     -14018.063     -14018.063      279.42207      279.42207      47904.694      47904.694     -592.91227     -592.91227    
Loop time of 285.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.427 hours/ns, 3.497 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.92     | 284.92     | 284.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15441    | 0.15441    | 0.15441    |   0.0 |  0.05
Output  | 0.00019005 | 0.00019005 | 0.00019005 |   0.0 |  0.00
Modify  | 0.7641     | 0.7641     | 0.7641     |   0.0 |  0.27
Other   |            | 0.1022     |            |       |  0.04

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

Total # of neighbors = 343620
Ave neighs/atom = 85.905
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.348713837916, Press = 1.57337621347441
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13873.626     -13873.626     -14018.063     -14018.063      279.42207      279.42207      47904.694      47904.694     -592.91227     -592.91227    
     48000  -13878.785     -13878.785     -14021.539     -14021.539      276.16787      276.16787      47805.041      47805.041      1829.3605      1829.3605    
Loop time of 288.127 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 80.035 hours/ns, 3.471 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.09     | 287.09     | 287.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15523    | 0.15523    | 0.15523    |   0.0 |  0.05
Output  | 0.00019439 | 0.00019439 | 0.00019439 |   0.0 |  0.00
Modify  | 0.77885    | 0.77885    | 0.77885    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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

Total # of neighbors = 343678
Ave neighs/atom = 85.9195
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.382044411952, Press = 1.2004798153529
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13878.785     -13878.785     -14021.539     -14021.539      276.16787      276.16787      47805.041      47805.041      1829.3605      1829.3605    
     49000  -13872.221     -13872.221     -14014.822     -14014.822      275.87115      275.87115      47894.63       47894.63      -8.5558686     -8.5558686    
Loop time of 287.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.769 hours/ns, 3.482 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.13     | 286.13     | 286.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15514    | 0.15514    | 0.15514    |   0.0 |  0.05
Output  | 0.00018908 | 0.00018908 | 0.00018908 |   0.0 |  0.00
Modify  | 0.77872    | 0.77872    | 0.77872    |   0.0 |  0.27
Other   |            | 0.1038     |            |       |  0.04

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

Total # of neighbors = 343714
Ave neighs/atom = 85.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 = 273.403210292891, Press = -0.385507648155265
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13872.221     -13872.221     -14014.822     -14014.822      275.87115      275.87115      47894.63       47894.63      -8.5558686     -8.5558686    
     50000  -13877.123     -13877.123     -14018.122     -14018.122      272.77131      272.77131      47925.788      47925.788     -1268.3515     -1268.3515    
Loop time of 283.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.654 hours/ns, 3.532 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.14     | 282.14     | 282.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15335    | 0.15335    | 0.15335    |   0.0 |  0.05
Output  | 0.00019385 | 0.00019385 | 0.00019385 |   0.0 |  0.00
Modify  | 0.76285    | 0.76285    | 0.76285    |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  0.04

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

Total # of neighbors = 343658
Ave neighs/atom = 85.9145
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.409608821306, Press = 0.736562799514376
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13877.123     -13877.123     -14018.122     -14018.122      272.77131      272.77131      47925.788      47925.788     -1268.3515     -1268.3515    
     51000  -13879.054     -13879.054     -14021.35      -14021.35       275.28066      275.28066      47863.955      47863.955      116.56831      116.56831    
Loop time of 281.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.320 hours/ns, 3.547 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 280.94     | 280.94     | 280.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15365    | 0.15365    | 0.15365    |   0.0 |  0.05
Output  | 0.00019043 | 0.00019043 | 0.00019043 |   0.0 |  0.00
Modify  | 0.75193    | 0.75193    | 0.75193    |   0.0 |  0.27
Other   |            | 0.1021     |            |       |  0.04

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

Total # of neighbors = 343612
Ave neighs/atom = 85.903
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.410638951419, Press = 1.49972606794115
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13879.054     -13879.054     -14021.35      -14021.35       275.28066      275.28066      47863.955      47863.955      116.56831      116.56831    
     52000  -13878.896     -13878.896     -14018.351     -14018.351      269.78445      269.78445      47832.774      47832.774      1308.8923      1308.8923    
Loop time of 281.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.218 hours/ns, 3.551 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 280.58     | 280.58     | 280.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15329    | 0.15329    | 0.15329    |   0.0 |  0.05
Output  | 0.00019206 | 0.00019206 | 0.00019206 |   0.0 |  0.00
Modify  | 0.75611    | 0.75611    | 0.75611    |   0.0 |  0.27
Other   |            | 0.1017     |            |       |  0.04

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

Total # of neighbors = 343702
Ave neighs/atom = 85.9255
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.398679938879, Press = 0.527549492340182
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13878.896     -13878.896     -14018.351     -14018.351      269.78445      269.78445      47832.774      47832.774      1308.8923      1308.8923    
     53000  -13875.734     -13875.734     -14016.523     -14016.523      272.36595      272.36595      47925.536      47925.536     -1083.6558     -1083.6558    
Loop time of 285.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.328 hours/ns, 3.502 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.56     | 284.56     | 284.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15374    | 0.15374    | 0.15374    |   0.0 |  0.05
Output  | 0.00024237 | 0.00024237 | 0.00024237 |   0.0 |  0.00
Modify  | 0.7675     | 0.7675     | 0.7675     |   0.0 |  0.27
Other   |            | 0.1034     |            |       |  0.04

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

Total # of neighbors = 343760
Ave neighs/atom = 85.94
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.410791651891, Press = 0.134157210449819
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13875.734     -13875.734     -14016.523     -14016.523      272.36595      272.36595      47925.536      47925.536     -1083.6558     -1083.6558    
     54000  -13878.118     -13878.118     -14017.419     -14017.419      269.48743      269.48743      47912.056      47912.056     -1025.4708     -1025.4708    
Loop time of 286.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.631 hours/ns, 3.488 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.65     | 285.65     | 285.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1551     | 0.1551     | 0.1551     |   0.0 |  0.05
Output  | 0.00018834 | 0.00018834 | 0.00018834 |   0.0 |  0.00
Modify  | 0.76723    | 0.76723    | 0.76723    |   0.0 |  0.27
Other   |            | 0.1035     |            |       |  0.04

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

Total # of neighbors = 343632
Ave neighs/atom = 85.908
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.405369138023, Press = 1.5536593539813
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13878.118     -13878.118     -14017.419     -14017.419      269.48743      269.48743      47912.056      47912.056     -1025.4708     -1025.4708    
     55000  -13877.511     -13877.511     -14018.726     -14018.726      273.19115      273.19115      47852.18       47852.18       731.64675      731.64675    
Loop time of 284.644 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.068 hours/ns, 3.513 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.6      | 283.6      | 283.6      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15725    | 0.15725    | 0.15725    |   0.0 |  0.06
Output  | 0.00024484 | 0.00024484 | 0.00024484 |   0.0 |  0.00
Modify  | 0.78065    | 0.78065    | 0.78065    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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

Total # of neighbors = 343668
Ave neighs/atom = 85.917
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.401632572814, Press = 0.663139882559101
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13877.511     -13877.511     -14018.726     -14018.726      273.19115      273.19115      47852.18       47852.18       731.64675      731.64675    
     56000  -13881.1       -13881.1       -14020.067     -14020.067      268.84131      268.84131      47869.998      47869.998     -89.837181     -89.837181    
Loop time of 287.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 79.988 hours/ns, 3.473 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 286.91     | 286.91     | 286.91     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15468    | 0.15468    | 0.15468    |   0.0 |  0.05
Output  | 0.00023334 | 0.00023334 | 0.00023334 |   0.0 |  0.00
Modify  | 0.78551    | 0.78551    | 0.78551    |   0.0 |  0.27
Other   |            | 0.1039     |            |       |  0.04

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

Total # of neighbors = 343750
Ave neighs/atom = 85.9375
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.3995921303, Press = 0.469542667878909
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13881.1       -13881.1       -14020.067     -14020.067      268.84131      268.84131      47869.998      47869.998     -89.837181     -89.837181    
     57000  -13877.272     -13877.272     -14018.166     -14018.166      272.56966      272.56966      47892.379      47892.379     -405.30586     -405.30586    
Loop time of 286.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.566 hours/ns, 3.491 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.4      | 285.4      | 285.4      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15499    | 0.15499    | 0.15499    |   0.0 |  0.05
Output  | 0.00023417 | 0.00023417 | 0.00023417 |   0.0 |  0.00
Modify  | 0.77507    | 0.77507    | 0.77507    |   0.0 |  0.27
Other   |            | 0.1035     |            |       |  0.04

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

Total # of neighbors = 343674
Ave neighs/atom = 85.9185
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.363608155004, Press = 0.412296899137389
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13877.272     -13877.272     -14018.166     -14018.166      272.56966      272.56966      47892.379      47892.379     -405.30586     -405.30586    
     58000  -13878.508     -13878.508     -14020.098     -14020.098      273.91501      273.91501      47902.655      47902.655     -899.74419     -899.74419    
Loop time of 285.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.399 hours/ns, 3.498 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 284.8      | 284.8      | 284.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15478    | 0.15478    | 0.15478    |   0.0 |  0.05
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.77618    | 0.77618    | 0.77618    |   0.0 |  0.27
Other   |            | 0.1045     |            |       |  0.04

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

Total # of neighbors = 343692
Ave neighs/atom = 85.923
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.361148892013, Press = 1.16261379760427
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13878.508     -13878.508     -14020.098     -14020.098      273.91501      273.91501      47902.655      47902.655     -899.74419     -899.74419    
     59000  -13873.841     -13873.841     -14017.227     -14017.227      277.39008      277.39008      47824.505      47824.505      1749.0927      1749.0927    
Loop time of 284.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 78.944 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.17     | 283.17     | 283.17     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15424    | 0.15424    | 0.15424    |   0.0 |  0.05
Output  | 0.00023623 | 0.00023623 | 0.00023623 |   0.0 |  0.00
Modify  | 0.76775    | 0.76775    | 0.76775    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  0.04

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

Total # of neighbors = 343674
Ave neighs/atom = 85.9185
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.376930676229, Press = 1.06774321336626
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13873.841     -13873.841     -14017.227     -14017.227      277.39008      277.39008      47824.505      47824.505      1749.0927      1749.0927    
     60000  -13880.178     -13880.178     -14021.614     -14021.614      273.61793      273.61793      47873.638      47873.638     -254.8189      -254.8189     
Loop time of 286.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.518 hours/ns, 3.493 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.23     | 285.23     | 285.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15423    | 0.15423    | 0.15423    |   0.0 |  0.05
Output  | 0.00018939 | 0.00018939 | 0.00018939 |   0.0 |  0.00
Modify  | 0.77637    | 0.77637    | 0.77637    |   0.0 |  0.27
Other   |            | 0.1037     |            |       |  0.04

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

Total # of neighbors = 343836
Ave neighs/atom = 85.959
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.39314253524, Press = -0.179220653328437
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13880.178     -13880.178     -14021.614     -14021.614      273.61793      273.61793      47873.638      47873.638     -254.8189      -254.8189     
     61000  -13872.327     -13872.327     -14017.965     -14017.965      281.74631      281.74631      47943.674      47943.674     -1728.4648     -1728.4648    
Loop time of 286.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.689 hours/ns, 3.486 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 285.85     | 285.85     | 285.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15345    | 0.15345    | 0.15345    |   0.0 |  0.05
Output  | 0.00019033 | 0.00019033 | 0.00019033 |   0.0 |  0.00
Modify  | 0.77592    | 0.77592    | 0.77592    |   0.0 |  0.27
Other   |            | 0.1033     |            |       |  0.04

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

Total # of neighbors = 343748
Ave neighs/atom = 85.937
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.412197739742, Press = 0.458280013222603
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13872.327     -13872.327     -14017.965     -14017.965      281.74631      281.74631      47943.674      47943.674     -1728.4648     -1728.4648    
     62000  -13879.277     -13879.277     -14019.988     -14019.988      272.21489      272.21489      47876.927      47876.927     -142.26816     -142.26816    
Loop time of 284.566 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.046 hours/ns, 3.514 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 283.55     | 283.55     | 283.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15392    | 0.15392    | 0.15392    |   0.0 |  0.05
Output  | 0.00019027 | 0.00019027 | 0.00019027 |   0.0 |  0.00
Modify  | 0.76416    | 0.76416    | 0.76416    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  0.04

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

Total # of neighbors = 343600
Ave neighs/atom = 85.9
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.41921564172, Press = 0.915153993883779
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13879.277     -13879.277     -14019.988     -14019.988      272.21489      272.21489      47876.927      47876.927     -142.26816     -142.26816    
     63000  -13875.875     -13875.875     -14019.638     -14019.638      278.11932      278.11932      47881.613      47881.613     -187.44736     -187.44736    
Loop time of 276.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.721 hours/ns, 3.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 275.21     | 275.21     | 275.21     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1507     | 0.1507     | 0.1507     |   0.0 |  0.05
Output  | 0.0001876  | 0.0001876  | 0.0001876  |   0.0 |  0.00
Modify  | 0.73516    | 0.73516    | 0.73516    |   0.0 |  0.27
Other   |            | 0.1009     |            |       |  0.04

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

Total # of neighbors = 343750
Ave neighs/atom = 85.9375
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.398518656315, Press = 0.4490002455655
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13875.875     -13875.875     -14019.638     -14019.638      278.11932      278.11932      47881.613      47881.613     -187.44736     -187.44736    
     64000  -13878.087     -13878.087     -14019.915     -14019.915      274.37541      274.37541      47882.297      47882.297     -311.63586     -311.63586    
Loop time of 280.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.308 ns/day, 77.861 hours/ns, 3.568 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 279.3      | 279.3      | 279.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15198    | 0.15198    | 0.15198    |   0.0 |  0.05
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.74966    | 0.74966    | 0.74966    |   0.0 |  0.27
Other   |            | 0.1017     |            |       |  0.04

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

Total # of neighbors = 343768
Ave neighs/atom = 85.942
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.376098151374, Press = 0.594465072134914
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13878.087     -13878.087     -14019.915     -14019.915      274.37541      274.37541      47882.297      47882.297     -311.63586     -311.63586    
     65000  -13877.831     -13877.831     -14017.937     -14017.937      271.04473      271.04473      47863.059      47863.059      501.76911      501.76911    
Loop time of 279.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.309 ns/day, 77.713 hours/ns, 3.574 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 278.77     | 278.77     | 278.77     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.05
Output  | 0.00023283 | 0.00023283 | 0.00023283 |   0.0 |  0.00
Modify  | 0.7456     | 0.7456     | 0.7456     |   0.0 |  0.27
Other   |            | 0.1018     |            |       |  0.04

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

Total # of neighbors = 343752
Ave neighs/atom = 85.938
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.376253029444, Press = 0.55192703290948
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13877.831     -13877.831     -14017.937     -14017.937      271.04473      271.04473      47863.059      47863.059      501.76911      501.76911    
     66000  -13876.91      -13876.91      -14018.256     -14018.256      273.44374      273.44374      47878.624      47878.624      54.869871      54.869871    
Loop time of 282.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.408 hours/ns, 3.543 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 281.24     | 281.24     | 281.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15511    | 0.15511    | 0.15511    |   0.0 |  0.05
Output  | 0.00018827 | 0.00018827 | 0.00018827 |   0.0 |  0.00
Modify  | 0.76922    | 0.76922    | 0.76922    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  0.04

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

Total # of neighbors = 343640
Ave neighs/atom = 85.91
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.372001806279, Press = 0.406866059617217
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13876.91      -13876.91      -14018.256     -14018.256      273.44374      273.44374      47878.624      47878.624      54.869871      54.869871    
     67000  -13878.988     -13878.988     -14021.416     -14021.416      275.53604      275.53604      47887.889      47887.889     -601.42707     -601.42707    
Loop time of 277.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.311 ns/day, 77.185 hours/ns, 3.599 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 276.89     | 276.89     | 276.89     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14913    | 0.14913    | 0.14913    |   0.0 |  0.05
Output  | 0.00023199 | 0.00023199 | 0.00023199 |   0.0 |  0.00
Modify  | 0.73128    | 0.73128    | 0.73128    |   0.0 |  0.26
Other   |            | 0.1        |            |       |  0.04

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

Total # of neighbors = 343700
Ave neighs/atom = 85.925
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.404233456855, Press = 0.523039177472139
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13878.988     -13878.988     -14021.416     -14021.416      275.53604      275.53604      47887.889      47887.889     -601.42707     -601.42707    
     68000  -13876.475     -13876.475     -14018.627     -14018.627      275.00244      275.00244      47867.951      47867.951      267.12554      267.12554    
Loop time of 282.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.562 hours/ns, 3.536 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 281.81     | 281.81     | 281.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15461    | 0.15461    | 0.15461    |   0.0 |  0.05
Output  | 0.00019275 | 0.00019275 | 0.00019275 |   0.0 |  0.00
Modify  | 0.76192    | 0.76192    | 0.76192    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  0.04

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

Total # of neighbors = 343672
Ave neighs/atom = 85.918
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.397630218502, Press = 0.491326667712605
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13876.475     -13876.475     -14018.627     -14018.627      275.00244      275.00244      47867.951      47867.951      267.12554      267.12554    
     69000  -13878.747     -13878.747     -14021.761     -14021.761      276.67083      276.67083      47891.682      47891.682     -839.77922     -839.77922    
Loop time of 281.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.249 hours/ns, 3.550 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 280.69     | 280.69     | 280.69     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15208    | 0.15208    | 0.15208    |   0.0 |  0.05
Output  | 0.00019805 | 0.00019805 | 0.00019805 |   0.0 |  0.00
Modify  | 0.75729    | 0.75729    | 0.75729    |   0.0 |  0.27
Other   |            | 0.1019     |            |       |  0.04

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

Total # of neighbors = 343762
Ave neighs/atom = 85.9405
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.367093871994, Press = 0.0921381836780344
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13878.747     -13878.747     -14021.761     -14021.761      276.67083      276.67083      47891.682      47891.682     -839.77922     -839.77922    
     70000  -13875.754     -13875.754     -14019.681     -14019.681      278.43703      278.43703      47922.094      47922.094     -1399.5763     -1399.5763    
Loop time of 281.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.180 hours/ns, 3.553 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 280.44     | 280.44     | 280.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15246    | 0.15246    | 0.15246    |   0.0 |  0.05
Output  | 0.0001962  | 0.0001962  | 0.0001962  |   0.0 |  0.00
Modify  | 0.75633    | 0.75633    | 0.75633    |   0.0 |  0.27
Other   |            | 0.1014     |            |       |  0.04

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

Total # of neighbors = 343672
Ave neighs/atom = 85.918
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.342601234133, Press = 0.733800150337427
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13875.754     -13875.754     -14019.681     -14019.681      278.43703      278.43703      47922.094      47922.094     -1399.5763     -1399.5763    
     71000  -13875.778     -13875.778     -14018.589     -14018.589      276.27816      276.27816      47836.806      47836.806      1177.1867      1177.1867    
Loop time of 274.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.248 hours/ns, 3.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 273.52     | 273.52     | 273.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14903    | 0.14903    | 0.14903    |   0.0 |  0.05
Output  | 0.00019268 | 0.00019268 | 0.00019268 |   0.0 |  0.00
Modify  | 0.72312    | 0.72312    | 0.72312    |   0.0 |  0.26
Other   |            | 0.1001     |            |       |  0.04

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

Total # of neighbors = 343684
Ave neighs/atom = 85.921
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.326546306946, Press = 1.0601625187105
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13875.778     -13875.778     -14018.589     -14018.589      276.27816      276.27816      47836.806      47836.806      1177.1867      1177.1867    
     72000  -13877.522     -13877.522     -14019.786     -14019.786      275.21876      275.21876      47838.826      47838.826      1015.46        1015.46      
Loop time of 275.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.605 hours/ns, 3.626 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 274.79     | 274.79     | 274.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14956    | 0.14956    | 0.14956    |   0.0 |  0.05
Output  | 0.00019171 | 0.00019171 | 0.00019171 |   0.0 |  0.00
Modify  | 0.73398    | 0.73398    | 0.73398    |   0.0 |  0.27
Other   |            | 0.1005     |            |       |  0.04

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

Total # of neighbors = 343798
Ave neighs/atom = 85.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"
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
47876.7307830317

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0