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

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

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

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

kim_interactions Al

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

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


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_353977746962_001#item-citation

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

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

Performance: 1.519 ns/day, 15.798 hours/ns, 17.584 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 56.719     | 56.719     | 56.719     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022451   | 0.022451   | 0.022451   |   0.0 |  0.04
Output  | 0.00019837 | 0.00019837 | 0.00019837 |   0.0 |  0.00
Modify  | 0.11859    | 0.11859    | 0.11859    |   0.0 |  0.21
Other   |            | 0.01091    |            |       |  0.02

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

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

Performance: 1.423 ns/day, 16.860 hours/ns, 16.475 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.547     | 60.547     | 60.547     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.04
Output  | 6.7026e-05 | 6.7026e-05 | 6.7026e-05 |   0.0 |  0.00
Modify  | 0.11722    | 0.11722    | 0.11722    |   0.0 |  0.19
Other   |            | 0.0107     |            |       |  0.02

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

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

Performance: 1.417 ns/day, 16.933 hours/ns, 16.405 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.807     | 60.807     | 60.807     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02172    | 0.02172    | 0.02172    |   0.0 |  0.04
Output  | 6.4601e-05 | 6.4601e-05 | 6.4601e-05 |   0.0 |  0.00
Modify  | 0.11732    | 0.11732    | 0.11732    |   0.0 |  0.19
Other   |            | 0.0108     |            |       |  0.02

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

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

Performance: 1.422 ns/day, 16.883 hours/ns, 16.453 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.628     | 60.628     | 60.628     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022038   | 0.022038   | 0.022038   |   0.0 |  0.04
Output  | 6.1867e-05 | 6.1867e-05 | 6.1867e-05 |   0.0 |  0.00
Modify  | 0.11762    | 0.11762    | 0.11762    |   0.0 |  0.19
Other   |            | 0.01051    |            |       |  0.02

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

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

Performance: 1.417 ns/day, 16.939 hours/ns, 16.399 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.83      | 60.83      | 60.83      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02194    | 0.02194    | 0.02194    |   0.0 |  0.04
Output  | 5.1567e-05 | 5.1567e-05 | 5.1567e-05 |   0.0 |  0.00
Modify  | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.19
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 281108
Ave neighs/atom = 70.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 317.169623242409, Press = -181.816681451509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13107.959     -13107.959     -13267.672     -13267.672      308.97666      308.97666      67512.262      67512.262     -544.36761     -544.36761    
      6000  -13108.826     -13108.826     -13270.875     -13270.875      313.4946       313.4946       67452.395      67452.395     -53.123355     -53.123355    
Loop time of 60.8186 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.421 ns/day, 16.894 hours/ns, 16.442 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.665     | 60.665     | 60.665     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02191    | 0.02191    | 0.02191    |   0.0 |  0.04
Output  | 5.4943e-05 | 5.4943e-05 | 5.4943e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 280006
Ave neighs/atom = 70.0015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.763211027465, Press = 31.4368884313333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13108.826     -13108.826     -13270.875     -13270.875      313.4946       313.4946       67452.395      67452.395     -53.123355     -53.123355    
      7000  -13109.949     -13109.949     -13273.083     -13273.083      315.59343      315.59343      67301.572      67301.572      1527.049       1527.049     
Loop time of 60.8935 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.915 hours/ns, 16.422 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.74      | 60.74      | 60.74      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021942   | 0.021942   | 0.021942   |   0.0 |  0.04
Output  | 4.796e-05  | 4.796e-05  | 4.796e-05  |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 280940
Ave neighs/atom = 70.235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 313.180494397223, Press = -9.89316345466745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13109.949     -13109.949     -13273.083     -13273.083      315.59343      315.59343      67301.572      67301.572      1527.049       1527.049     
      8000  -13108.831     -13108.831     -13270.897     -13270.897      313.52765      313.52765      67489.367      67489.367     -524.51018     -524.51018    
Loop time of 60.8786 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.911 hours/ns, 16.426 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.725     | 60.725     | 60.725     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021948   | 0.021948   | 0.021948   |   0.0 |  0.04
Output  | 4.6367e-05 | 4.6367e-05 | 4.6367e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 282348
Ave neighs/atom = 70.587
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.849929991134, Press = -10.4067083308301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13108.831     -13108.831     -13270.897     -13270.897      313.52765      313.52765      67489.367      67489.367     -524.51018     -524.51018    
      9000  -13112.398     -13112.398     -13275.573     -13275.573      315.67285      315.67285      67477.542      67477.542     -654.80353     -654.80353    
Loop time of 60.8513 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.903 hours/ns, 16.434 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.698     | 60.698     | 60.698     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021963   | 0.021963   | 0.021963   |   0.0 |  0.04
Output  | 4.9182e-05 | 4.9182e-05 | 4.9182e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 280292
Ave neighs/atom = 70.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.652593255444, Press = 0.9619143994751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13112.398     -13112.398     -13275.573     -13275.573      315.67285      315.67285      67477.542      67477.542     -654.80353     -654.80353    
     10000  -13111.653     -13111.653     -13272.55      -13272.55       311.26641      311.26641      67427.406      67427.406      11.655748      11.655748    
Loop time of 60.8247 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.896 hours/ns, 16.441 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.671     | 60.671     | 60.671     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021907   | 0.021907   | 0.021907   |   0.0 |  0.04
Output  | 4.9673e-05 | 4.9673e-05 | 4.9673e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.20
Other   |            | 0.01077    |            |       |  0.02

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

Total # of neighbors = 280790
Ave neighs/atom = 70.1975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.240862632935, Press = -0.204419388954601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13111.653     -13111.653     -13272.55      -13272.55       311.26641      311.26641      67427.406      67427.406      11.655748      11.655748    
     11000  -13107.158     -13107.158     -13272.191     -13272.191      319.26694      319.26694      67425.777      67425.777      187.49753      187.49753    
Loop time of 60.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.907 hours/ns, 16.430 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.713     | 60.713     | 60.713     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021832   | 0.021832   | 0.021832   |   0.0 |  0.04
Output  | 4.6176e-05 | 4.6176e-05 | 4.6176e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 281074
Ave neighs/atom = 70.2685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.46719672702, Press = -2.30808977991063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13107.158     -13107.158     -13272.191     -13272.191      319.26694      319.26694      67425.777      67425.777      187.49753      187.49753    
     12000  -13105.085     -13105.085     -13268.737     -13268.737      316.59708      316.59708      67486.597      67486.597     -274.79003     -274.79003    
Loop time of 60.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.943 hours/ns, 16.395 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.841     | 60.841     | 60.841     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021918   | 0.021918   | 0.021918   |   0.0 |  0.04
Output  | 4.9153e-05 | 4.9153e-05 | 4.9153e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.20
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 281244
Ave neighs/atom = 70.311
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.588406887965, Press = -6.05778199627528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13105.085     -13105.085     -13268.737     -13268.737      316.59708      316.59708      67486.597      67486.597     -274.79003     -274.79003    
     13000  -13113.974     -13113.974     -13273.926     -13273.926      309.43784      309.43784      67538.931      67538.931     -1308.4131     -1308.4131    
Loop time of 60.8045 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.421 ns/day, 16.890 hours/ns, 16.446 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.651     | 60.651     | 60.651     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022017   | 0.022017   | 0.022017   |   0.0 |  0.04
Output  | 4.9854e-05 | 4.9854e-05 | 4.9854e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 280668
Ave neighs/atom = 70.167
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.815333583381, Press = 2.4893052052016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13113.974     -13113.974     -13273.926     -13273.926      309.43784      309.43784      67538.931      67538.931     -1308.4131     -1308.4131    
     14000  -13106.407     -13106.407     -13272.054     -13272.054      320.45691      320.45691      67379.548      67379.548      691.15628      691.15628    
Loop time of 60.9682 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.936 hours/ns, 16.402 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.814     | 60.814     | 60.814     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022034   | 0.022034   | 0.022034   |   0.0 |  0.04
Output  | 5.0074e-05 | 5.0074e-05 | 5.0074e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.20
Other   |            | 0.01055    |            |       |  0.02

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

Total # of neighbors = 280316
Ave neighs/atom = 70.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.726225044761, Press = 1.63665755021402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13106.407     -13106.407     -13272.054     -13272.054      320.45691      320.45691      67379.548      67379.548      691.15628      691.15628    
     15000  -13110.396     -13110.396     -13273.84      -13273.84       316.19349      316.19349      67437.794      67437.794     -115.25552     -115.25552    
Loop time of 61.0728 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.919     | 60.919     | 60.919     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021985   | 0.021985   | 0.021985   |   0.0 |  0.04
Output  | 4.6968e-05 | 4.6968e-05 | 4.6968e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.20
Other   |            | 0.01062    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5835 ave        5835 max        5835 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:       281348 ave      281348 max      281348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281348
Ave neighs/atom = 70.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.599478772319, Press = -3.41644547643766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13110.396     -13110.396     -13273.84      -13273.84       316.19349      316.19349      67437.794      67437.794     -115.25552     -115.25552    
     16000  -13105.236     -13105.236     -13267.778     -13267.778      314.44821      314.44821      67553.968      67553.968     -976.61277     -976.61277    
Loop time of 60.8753 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.910 hours/ns, 16.427 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.722     | 60.722     | 60.722     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021949   | 0.021949   | 0.021949   |   0.0 |  0.04
Output  | 4.9352e-05 | 4.9352e-05 | 4.9352e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 281046
Ave neighs/atom = 70.2615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.625018351597, Press = -0.904288192431904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13105.236     -13105.236     -13267.778     -13267.778      314.44821      314.44821      67553.968      67553.968     -976.61277     -976.61277    
     17000  -13111.488     -13111.488     -13270.195     -13270.195      307.02775      307.02775      67437.416      67437.416      97.221501      97.221501    
Loop time of 60.7827 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.421 ns/day, 16.884 hours/ns, 16.452 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.629     | 60.629     | 60.629     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022033   | 0.022033   | 0.022033   |   0.0 |  0.04
Output  | 4.763e-05  | 4.763e-05  | 4.763e-05  |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.20
Other   |            | 0.01054    |            |       |  0.02

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

Total # of neighbors = 279752
Ave neighs/atom = 69.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 = 312.58996006233, Press = 3.0798183989896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13111.488     -13111.488     -13270.195     -13270.195      307.02775      307.02775      67437.416      67437.416      97.221501      97.221501    
     18000  -13106.419     -13106.419     -13271.185     -13271.185      318.75113      318.75113      67374.305      67374.305      860.64725      860.64725    
Loop time of 60.9351 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.782     | 60.782     | 60.782     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021924   | 0.021924   | 0.021924   |   0.0 |  0.04
Output  | 5.4572e-05 | 5.4572e-05 | 5.4572e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.20
Other   |            | 0.01051    |            |       |  0.02

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

Total # of neighbors = 280950
Ave neighs/atom = 70.2375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.478326060998, Press = -1.21796579638223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13106.419     -13106.419     -13271.185     -13271.185      318.75113      318.75113      67374.305      67374.305      860.64725      860.64725    
     19000  -13109.352     -13109.352     -13272.252     -13272.252      315.14055      315.14055      67489.9        67489.9       -605.81314     -605.81314    
Loop time of 61.0429 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.889     | 60.889     | 60.889     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022143   | 0.022143   | 0.022143   |   0.0 |  0.04
Output  | 4.9943e-05 | 4.9943e-05 | 4.9943e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.20
Other   |            | 0.01054    |            |       |  0.02

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

Total # of neighbors = 281348
Ave neighs/atom = 70.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.531350060441, Press = -2.43252943988675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13109.352     -13109.352     -13272.252     -13272.252      315.14055      315.14055      67489.9        67489.9       -605.81314     -605.81314    
     20000  -13109.948     -13109.948     -13272.406     -13272.406      314.28609      314.28609      67487.263      67487.263     -520.36297     -520.36297    
Loop time of 61.0316 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.878     | 60.878     | 60.878     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021767   | 0.021767   | 0.021767   |   0.0 |  0.04
Output  | 5.0275e-05 | 5.0275e-05 | 5.0275e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.20
Other   |            | 0.01067    |            |       |  0.02

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

Total # of neighbors = 280576
Ave neighs/atom = 70.144
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.41807087489, Press = 1.5173614796294
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13109.948     -13109.948     -13272.406     -13272.406      314.28609      314.28609      67487.263      67487.263     -520.36297     -520.36297    
     21000  -13111.39      -13111.39      -13270.839     -13270.839      308.46391      308.46391      67351.28       67351.28       1016.1021      1016.1021    
Loop time of 60.8796 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.911 hours/ns, 16.426 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.726     | 60.726     | 60.726     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021981   | 0.021981   | 0.021981   |   0.0 |  0.04
Output  | 4.9032e-05 | 4.9032e-05 | 4.9032e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.20
Other   |            | 0.01056    |            |       |  0.02

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

Total # of neighbors = 280730
Ave neighs/atom = 70.1825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.470317647514, Press = -0.169773789191827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13111.39      -13111.39      -13270.839     -13270.839      308.46391      308.46391      67351.28       67351.28       1016.1021      1016.1021    
     22000  -13103.042     -13103.042     -13269.418     -13269.418      321.86541      321.86541      67481.682      67481.682     -165.3196      -165.3196     
Loop time of 60.9419 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.788     | 60.788     | 60.788     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021956   | 0.021956   | 0.021956   |   0.0 |  0.04
Output  | 5.6326e-05 | 5.6326e-05 | 5.6326e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 281708
Ave neighs/atom = 70.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.596504425643, Press = -2.6156376234778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13103.042     -13103.042     -13269.418     -13269.418      321.86541      321.86541      67481.682      67481.682     -165.3196      -165.3196     
     23000  -13110.129     -13110.129     -13270.724     -13270.724      310.68064      310.68064      67525.815      67525.815     -914.9837      -914.9837     
Loop time of 60.8307 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.897 hours/ns, 16.439 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.677     | 60.677     | 60.677     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022058   | 0.022058   | 0.022058   |   0.0 |  0.04
Output  | 5.2268e-05 | 5.2268e-05 | 5.2268e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.20
Other   |            | 0.0106     |            |       |  0.02

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

Total # of neighbors = 280460
Ave neighs/atom = 70.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.670501355954, Press = 0.0523316749080067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13110.129     -13110.129     -13270.724     -13270.724      310.68064      310.68064      67525.815      67525.815     -914.9837      -914.9837     
     24000  -13107.482     -13107.482     -13270.764     -13270.764      315.88049      315.88049      67382.525      67382.525      745.83915      745.83915    
Loop time of 60.8906 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.914 hours/ns, 16.423 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.737     | 60.737     | 60.737     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021925   | 0.021925   | 0.021925   |   0.0 |  0.04
Output  | 5.302e-05  | 5.302e-05  | 5.302e-05  |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.20
Other   |            | 0.01052    |            |       |  0.02

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

Total # of neighbors = 280200
Ave neighs/atom = 70.05
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.773122472554, Press = 1.91524107957776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13107.482     -13107.482     -13270.764     -13270.764      315.88049      315.88049      67382.525      67382.525      745.83915      745.83915    
     25000  -13108.317     -13108.317     -13270.424     -13270.424      313.60717      313.60717      67365.376      67365.376      1052.6582      1052.6582    
Loop time of 60.8363 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.899 hours/ns, 16.438 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.683     | 60.683     | 60.683     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021879   | 0.021879   | 0.021879   |   0.0 |  0.04
Output  | 5.5985e-05 | 5.5985e-05 | 5.5985e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.20
Other   |            | 0.01056    |            |       |  0.02

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

Total # of neighbors = 281472
Ave neighs/atom = 70.368
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.80573422973, Press = -1.69775672138832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13108.317     -13108.317     -13270.424     -13270.424      313.60717      313.60717      67365.376      67365.376      1052.6582      1052.6582    
     26000  -13105.938     -13105.938     -13268.948     -13268.948      315.35362      315.35362      67496.06       67496.06      -397.23934     -397.23934    
Loop time of 60.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.917 hours/ns, 16.420 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.746     | 60.746     | 60.746     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021905   | 0.021905   | 0.021905   |   0.0 |  0.04
Output  | 5.4172e-05 | 5.4172e-05 | 5.4172e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 281570
Ave neighs/atom = 70.3925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.93588964377, Press = -0.920042727829283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13105.938     -13105.938     -13268.948     -13268.948      315.35362      315.35362      67496.06       67496.06      -397.23934     -397.23934    
     27000  -13110.445     -13110.445     -13270.267     -13270.267      309.18701      309.18701      67444.849      67444.849      28.336994      28.336994    
Loop time of 60.9141 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.76      | 60.76      | 60.76      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021944   | 0.021944   | 0.021944   |   0.0 |  0.04
Output  | 5.0856e-05 | 5.0856e-05 | 5.0856e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.20
Other   |            | 0.01056    |            |       |  0.02

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

Total # of neighbors = 280204
Ave neighs/atom = 70.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.931149390838, Press = -0.156652301667447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13110.445     -13110.445     -13270.267     -13270.267      309.18701      309.18701      67444.849      67444.849      28.336994      28.336994    
     28000  -13109.834     -13109.834     -13272.047     -13272.047      313.81307      313.81307      67421.299      67421.299      187.4959       187.4959     
Loop time of 60.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.909 hours/ns, 16.428 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.719     | 60.719     | 60.719     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021832   | 0.021832   | 0.021832   |   0.0 |  0.04
Output  | 6.2016e-05 | 6.2016e-05 | 6.2016e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.20
Other   |            | 0.01074    |            |       |  0.02

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

Total # of neighbors = 281160
Ave neighs/atom = 70.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.91583226578, Press = -0.190705353445139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13109.834     -13109.834     -13272.047     -13272.047      313.81307      313.81307      67421.299      67421.299      187.4959       187.4959     
     29000  -13110.976     -13110.976     -13270.021     -13270.021      307.6829       307.6829       67448.027      67448.027      6.1517127      6.1517127    
Loop time of 60.9129 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.759     | 60.759     | 60.759     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022031   | 0.022031   | 0.022031   |   0.0 |  0.04
Output  | 6.1496e-05 | 6.1496e-05 | 6.1496e-05 |   0.0 |  0.00
Modify  | 0.1216     | 0.1216     | 0.1216     |   0.0 |  0.20
Other   |            | 0.01056    |            |       |  0.02

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

Total # of neighbors = 281066
Ave neighs/atom = 70.2665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.963400819937, Press = -1.54381372529176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13110.976     -13110.976     -13270.021     -13270.021      307.6829       307.6829       67448.027      67448.027      6.1517127      6.1517127    
     30000  -13104.808     -13104.808     -13270.41      -13270.41       320.36982      320.36982      67574.157      67574.157     -1309.9917     -1309.9917    
Loop time of 60.8536 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.904 hours/ns, 16.433 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.7       | 60.7       | 60.7       |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02207    | 0.02207    | 0.02207    |   0.0 |  0.04
Output  | 5.6887e-05 | 5.6887e-05 | 5.6887e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.20
Other   |            | 0.01057    |            |       |  0.02

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

Total # of neighbors = 281154
Ave neighs/atom = 70.2885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 313.036102902669, Press = 0.73011513332934
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13104.808     -13104.808     -13270.41      -13270.41       320.36982      320.36982      67574.157      67574.157     -1309.9917     -1309.9917    
     31000  -13104.608     -13104.608     -13269.161     -13269.161      318.33958      318.33958      67403.013      67403.013      669.62334      669.62334    
Loop time of 60.9162 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.762     | 60.762     | 60.762     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021893   | 0.021893   | 0.021893   |   0.0 |  0.04
Output  | 6.399e-05  | 6.399e-05  | 6.399e-05  |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.20
Other   |            | 0.01074    |            |       |  0.02

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

Total # of neighbors = 279616
Ave neighs/atom = 69.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 313.070472451838, Press = 0.601746560763921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13104.608     -13104.608     -13269.161     -13269.161      318.33958      318.33958      67403.013      67403.013      669.62334      669.62334    
     32000  -13108.82      -13108.82      -13270.255     -13270.255      312.30662      312.30662      67418.588      67418.588      370.3007       370.3007     
Loop time of 61.2167 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.063     | 61.063     | 61.063     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021902   | 0.021902   | 0.021902   |   0.0 |  0.04
Output  | 5.5425e-05 | 5.5425e-05 | 5.5425e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.20
Other   |            | 0.01073    |            |       |  0.02

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

Total # of neighbors = 281198
Ave neighs/atom = 70.2995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 313.04079654529, Press = -0.856747332133006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13108.82      -13108.82      -13270.255     -13270.255      312.30662      312.30662      67418.588      67418.588      370.3007       370.3007     
     33000  -13109.658     -13109.658     -13271.591     -13271.591      313.27191      313.27191      67479.06       67479.06      -385.89089     -385.89089    
Loop time of 61.1713 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.992 hours/ns, 16.348 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.017     | 61.017     | 61.017     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022118   | 0.022118   | 0.022118   |   0.0 |  0.04
Output  | 5.0765e-05 | 5.0765e-05 | 5.0765e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.20
Other   |            | 0.01051    |            |       |  0.02

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

Total # of neighbors = 281134
Ave neighs/atom = 70.2835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 313.004152012081, Press = -0.673544734689716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13109.658     -13109.658     -13271.591     -13271.591      313.27191      313.27191      67479.06       67479.06      -385.89089     -385.89089    
     34000  -13110.621     -13110.621     -13270.01      -13270.01       308.34897      308.34897      67450.793      67450.793      29.141928      29.141928    
Loop time of 60.9874 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.941 hours/ns, 16.397 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.833     | 60.833     | 60.833     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021915   | 0.021915   | 0.021915   |   0.0 |  0.04
Output  | 5.7037e-05 | 5.7037e-05 | 5.7037e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.20
Other   |            | 0.01067    |            |       |  0.02

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

Total # of neighbors = 280588
Ave neighs/atom = 70.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.924033805324, Press = 0.513145197090686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13110.621     -13110.621     -13270.01      -13270.01       308.34897      308.34897      67450.793      67450.793      29.141928      29.141928    
     35000  -13110.356     -13110.356     -13273.169     -13273.169      314.97336      314.97336      67363.627      67363.627      819.46969      819.46969    
Loop time of 61.0551 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.901     | 60.901     | 60.901     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022068   | 0.022068   | 0.022068   |   0.0 |  0.04
Output  | 5.1487e-05 | 5.1487e-05 | 5.1487e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  0.20
Other   |            | 0.01061    |            |       |  0.02

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

Total # of neighbors = 280888
Ave neighs/atom = 70.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.909682849502, Press = -0.150781391489175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13110.356     -13110.356     -13273.169     -13273.169      314.97336      314.97336      67363.627      67363.627      819.46969      819.46969    
     36000  -13106.768     -13106.768     -13267.406     -13267.406      310.76576      310.76576      67480.767      67480.767     -141.99019     -141.99019    
Loop time of 61.3752 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.408 ns/day, 17.049 hours/ns, 16.293 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.22      | 61.22      | 61.22      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022533   | 0.022533   | 0.022533   |   0.0 |  0.04
Output  | 5.3892e-05 | 5.3892e-05 | 5.3892e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.20
Other   |            | 0.01055    |            |       |  0.02

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

Total # of neighbors = 281826
Ave neighs/atom = 70.4565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.860160299902, Press = -1.82113625246312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13106.768     -13106.768     -13267.406     -13267.406      310.76576      310.76576      67480.767      67480.767     -141.99019     -141.99019    
     37000  -13110.564     -13110.564     -13270.843     -13270.843      310.07079      310.07079      67567.569      67567.569     -1417.2328     -1417.2328    
Loop time of 61.2867 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.132     | 61.132     | 61.132     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022104   | 0.022104   | 0.022104   |   0.0 |  0.04
Output  | 5.4041e-05 | 5.4041e-05 | 5.4041e-05 |   0.0 |  0.00
Modify  | 0.1218     | 0.1218     | 0.1218     |   0.0 |  0.20
Other   |            | 0.01072    |            |       |  0.02

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

Total # of neighbors = 280512
Ave neighs/atom = 70.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.869459808956, Press = 0.227720835455026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13110.564     -13110.564     -13270.843     -13270.843      310.07079      310.07079      67567.569      67567.569     -1417.2328     -1417.2328    
     38000  -13106.656     -13106.656     -13270.805     -13270.805      317.55796      317.55796      67401.239      67401.239      543.1128       543.1128     
Loop time of 61.124 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.979 hours/ns, 16.360 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.969     | 60.969     | 60.969     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02199    | 0.02199    | 0.02199    |   0.0 |  0.04
Output  | 0.00012288 | 0.00012288 | 0.00012288 |   0.0 |  0.00
Modify  | 0.12165    | 0.12165    | 0.12165    |   0.0 |  0.20
Other   |            | 0.01089    |            |       |  0.02

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

Total # of neighbors = 279798
Ave neighs/atom = 69.9495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.851524777786, Press = 0.194864550278422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13106.656     -13106.656     -13270.805     -13270.805      317.55796      317.55796      67401.239      67401.239      543.1128       543.1128     
     39000  -13113.403     -13113.403     -13275.351     -13275.351      313.30096      313.30096      67398.074      67398.074      237.44922      237.44922    
Loop time of 61.1623 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.990 hours/ns, 16.350 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.008     | 61.008     | 61.008     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022047   | 0.022047   | 0.022047   |   0.0 |  0.04
Output  | 5.3942e-05 | 5.3942e-05 | 5.3942e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.20
Other   |            | 0.01071    |            |       |  0.02

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

Total # of neighbors = 281284
Ave neighs/atom = 70.321
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.807376409422, Press = -0.717509946023638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13113.403     -13113.403     -13275.351     -13275.351      313.30096      313.30096      67398.074      67398.074      237.44922      237.44922    
     40000  -13108.433     -13108.433     -13267.958     -13267.958      308.61147      308.61147      67483.856      67483.856     -247.4414      -247.4414     
Loop time of 61.4483 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.406 ns/day, 17.069 hours/ns, 16.274 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.293     | 61.293     | 61.293     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02209    | 0.02209    | 0.02209    |   0.0 |  0.04
Output  | 5.834e-05  | 5.834e-05  | 5.834e-05  |   0.0 |  0.00
Modify  | 0.12199    | 0.12199    | 0.12199    |   0.0 |  0.20
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 281632
Ave neighs/atom = 70.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.766435031125, Press = -0.530168058224602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13108.433     -13108.433     -13267.958     -13267.958      308.61147      308.61147      67483.856      67483.856     -247.4414      -247.4414     
     41000  -13113.952     -13113.952     -13271.229     -13271.229      304.26326      304.26326      67449.931      67449.931     -184.77234     -184.77234    
Loop time of 61.3074 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.152     | 61.152     | 61.152     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022092   | 0.022092   | 0.022092   |   0.0 |  0.04
Output  | 5.1396e-05 | 5.1396e-05 | 5.1396e-05 |   0.0 |  0.00
Modify  | 0.1221     | 0.1221     | 0.1221     |   0.0 |  0.20
Other   |            | 0.01074    |            |       |  0.02

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

Total # of neighbors = 280704
Ave neighs/atom = 70.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.74795206006, Press = 0.331348976890707
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13113.952     -13113.952     -13271.229     -13271.229      304.26326      304.26326      67449.931      67449.931     -184.77234     -184.77234    
     42000  -13106.874     -13106.874     -13268.866     -13268.866      313.38435      313.38435      67346.462      67346.462      1242.0353      1242.0353    
Loop time of 61.4578 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.406 ns/day, 17.072 hours/ns, 16.271 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.303     | 61.303     | 61.303     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022017   | 0.022017   | 0.022017   |   0.0 |  0.04
Output  | 5.5054e-05 | 5.5054e-05 | 5.5054e-05 |   0.0 |  0.00
Modify  | 0.12175    | 0.12175    | 0.12175    |   0.0 |  0.20
Other   |            | 0.01065    |            |       |  0.02

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

Total # of neighbors = 280974
Ave neighs/atom = 70.2435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.726236410066, Press = -0.00291814703148664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13106.874     -13106.874     -13268.866     -13268.866      313.38435      313.38435      67346.462      67346.462      1242.0353      1242.0353    
     43000  -13109.401     -13109.401     -13271.884     -13271.884      314.3337       314.3337       67443.523      67443.523     -21.575981     -21.575981    
Loop time of 61.3637 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.408 ns/day, 17.045 hours/ns, 16.296 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.209     | 61.209     | 61.209     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022099   | 0.022099   | 0.022099   |   0.0 |  0.04
Output  | 4.7219e-05 | 4.7219e-05 | 4.7219e-05 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.20
Other   |            | 0.01078    |            |       |  0.02

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

Total # of neighbors = 281598
Ave neighs/atom = 70.3995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.748897464852, Press = -1.0635135327327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13109.401     -13109.401     -13271.884     -13271.884      314.3337       314.3337       67443.523      67443.523     -21.575981     -21.575981    
     44000  -13109.205     -13109.205     -13270.903     -13270.903      312.81683      312.81683      67539.461      67539.461     -1045.0352     -1045.0352    
Loop time of 61.5071 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.405 ns/day, 17.085 hours/ns, 16.258 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.353     | 61.353     | 61.353     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022023   | 0.022023   | 0.022023   |   0.0 |  0.04
Output  | 4.787e-05  | 4.787e-05  | 4.787e-05  |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.20
Other   |            | 0.01075    |            |       |  0.02

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

Total # of neighbors = 281038
Ave neighs/atom = 70.2595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.744404010115, Press = -0.137754136216695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13109.205     -13109.205     -13270.903     -13270.903      312.81683      312.81683      67539.461      67539.461     -1045.0352     -1045.0352    
     45000  -13110.668     -13110.668     -13270.572     -13270.572      309.34509      309.34509      67399.511      67399.511      468.40489      468.40489    
Loop time of 61.1828 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.028     | 61.028     | 61.028     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022055   | 0.022055   | 0.022055   |   0.0 |  0.04
Output  | 4.802e-05  | 4.802e-05  | 4.802e-05  |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.20
Other   |            | 0.01073    |            |       |  0.02

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

Total # of neighbors = 280288
Ave neighs/atom = 70.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.745638049838, Press = 0.470093269295546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13110.668     -13110.668     -13270.572     -13270.572      309.34509      309.34509      67399.511      67399.511      468.40489      468.40489    
     46000  -13111.223     -13111.223     -13274.844     -13274.844      316.53634      316.53634      67409.118      67409.118      87.604759      87.604759    
Loop time of 61.3622 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.408 ns/day, 17.045 hours/ns, 16.297 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.207     | 61.207     | 61.207     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022249   | 0.022249   | 0.022249   |   0.0 |  0.04
Output  | 5.0676e-05 | 5.0676e-05 | 5.0676e-05 |   0.0 |  0.00
Modify  | 0.12177    | 0.12177    | 0.12177    |   0.0 |  0.20
Other   |            | 0.01076    |            |       |  0.02

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

Total # of neighbors = 281060
Ave neighs/atom = 70.265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.689185224257, Press = -0.323677347899408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13111.223     -13111.223     -13274.844     -13274.844      316.53634      316.53634      67409.118      67409.118      87.604759      87.604759    
     47000  -13109.94      -13109.94      -13268.848     -13268.848      307.41879      307.41879      67467.075      67467.075     -112.32335     -112.32335    
Loop time of 61.2989 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.144     | 61.144     | 61.144     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021978   | 0.021978   | 0.021978   |   0.0 |  0.04
Output  | 4.6959e-05 | 4.6959e-05 | 4.6959e-05 |   0.0 |  0.00
Modify  | 0.12164    | 0.12164    | 0.12164    |   0.0 |  0.20
Other   |            | 0.0108     |            |       |  0.02

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

Total # of neighbors = 281252
Ave neighs/atom = 70.313
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.722743823497, Press = -0.340036121763371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13109.94      -13109.94      -13268.848     -13268.848      307.41879      307.41879      67467.075      67467.075     -112.32335     -112.32335    
     48000  -13109.815     -13109.815     -13269.748     -13269.748      309.39968      309.39968      67455.593      67455.593     -67.114706     -67.114706    
Loop time of 61.3574 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.408 ns/day, 17.044 hours/ns, 16.298 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.203     | 61.203     | 61.203     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022006   | 0.022006   | 0.022006   |   0.0 |  0.04
Output  | 4.6628e-05 | 4.6628e-05 | 4.6628e-05 |   0.0 |  0.00
Modify  | 0.12195    | 0.12195    | 0.12195    |   0.0 |  0.20
Other   |            | 0.01075    |            |       |  0.02

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

Total # of neighbors = 280878
Ave neighs/atom = 70.2195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.755442328882, Press = 0.166507044981627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13109.815     -13109.815     -13269.748     -13269.748      309.39968      309.39968      67455.593      67455.593     -67.114706     -67.114706    
     49000  -13108.252     -13108.252     -13269.342     -13269.342      311.64018      311.64018      67417.009      67417.009      406.00174      406.00174    
Loop time of 61.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.407 ns/day, 17.060 hours/ns, 16.283 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.26      | 61.26      | 61.26      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021998   | 0.021998   | 0.021998   |   0.0 |  0.04
Output  | 4.9062e-05 | 4.9062e-05 | 4.9062e-05 |   0.0 |  0.00
Modify  | 0.12184    | 0.12184    | 0.12184    |   0.0 |  0.20
Other   |            | 0.01096    |            |       |  0.02

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

Total # of neighbors = 280706
Ave neighs/atom = 70.1765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.803233534478, Press = -0.397918184057623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13108.252     -13108.252     -13269.342     -13269.342      311.64018      311.64018      67417.009      67417.009      406.00174      406.00174    
     50000  -13107.101     -13107.101     -13269.586     -13269.586      314.33715      314.33715      67488.941      67488.941     -440.2885      -440.2885     
Loop time of 61.2646 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.11      | 61.11      | 61.11      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022057   | 0.022057   | 0.022057   |   0.0 |  0.04
Output  | 4.8842e-05 | 4.8842e-05 | 4.8842e-05 |   0.0 |  0.00
Modify  | 0.12188    | 0.12188    | 0.12188    |   0.0 |  0.20
Other   |            | 0.01069    |            |       |  0.02

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

Total # of neighbors = 280868
Ave neighs/atom = 70.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.78713495541, Press = -0.418796549889486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13107.101     -13107.101     -13269.586     -13269.586      314.33715      314.33715      67488.941      67488.941     -440.2885      -440.2885     
     51000  -13106.202     -13106.202     -13265.302     -13265.302      307.7899       307.7899       67468.157      67468.157      120.67222      120.67222    
Loop time of 61.2641 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.109     | 61.109     | 61.109     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022111   | 0.022111   | 0.022111   |   0.0 |  0.04
Output  | 5.0194e-05 | 5.0194e-05 | 5.0194e-05 |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.20
Other   |            | 0.01076    |            |       |  0.02

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

Total # of neighbors = 280254
Ave neighs/atom = 70.0635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.784587580748, Press = 0.223874792593234
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13106.202     -13106.202     -13265.302     -13265.302      307.7899       307.7899       67468.157      67468.157      120.67222      120.67222    
     52000  -13105.8       -13105.8       -13270.192     -13270.192      318.02814      318.02814      67362.563      67362.563      1041.8646      1041.8646    
Loop time of 61.2523 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.097     | 61.097     | 61.097     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022049   | 0.022049   | 0.022049   |   0.0 |  0.04
Output  | 0.00011541 | 0.00011541 | 0.00011541 |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.20
Other   |            | 0.0111     |            |       |  0.02

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

Total # of neighbors = 280268
Ave neighs/atom = 70.067
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.773320347227, Press = -0.187850262764424
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13105.8       -13105.8       -13270.192     -13270.192      318.02814      318.02814      67362.563      67362.563      1041.8646      1041.8646    
     53000  -13111.309     -13111.309     -13271.212     -13271.212      309.34399      309.34399      67480.631      67480.631     -460.1413      -460.1413     
Loop time of 61.0953 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.94      | 60.94      | 60.94      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02236    | 0.02236    | 0.02236    |   0.0 |  0.04
Output  | 0.00010794 | 0.00010794 | 0.00010794 |   0.0 |  0.00
Modify  | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.20
Other   |            | 0.0107     |            |       |  0.02

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

Total # of neighbors = 281702
Ave neighs/atom = 70.4255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.780091348081, Press = -1.0831092799108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13111.309     -13111.309     -13271.212     -13271.212      309.34399      309.34399      67480.631      67480.631     -460.1413      -460.1413     
     54000  -13104.296     -13104.296     -13269.927     -13269.927      320.42403      320.42403      67555.127      67555.127     -1157.743      -1157.743     
Loop time of 61.0566 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.960 hours/ns, 16.378 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    | 60.9       | 60.9       | 60.9       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022525   | 0.022525   | 0.022525   |   0.0 |  0.04
Output  | 8.5481e-05 | 8.5481e-05 | 8.5481e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.20
Other   |            | 0.0109     |            |       |  0.02

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

Total # of neighbors = 280406
Ave neighs/atom = 70.1015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.791062671068, Press = 0.320105875139722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13104.296     -13104.296     -13269.927     -13269.927      320.42403      320.42403      67555.127      67555.127     -1157.743      -1157.743     
     55000  -13108.107     -13108.107     -13270.132     -13270.132      313.44887      313.44887      67406.993      67406.993      515.22291      515.22291    
Loop time of 60.9035 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.918 hours/ns, 16.419 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    | 60.746     | 60.746     | 60.746     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022877   | 0.022877   | 0.022877   |   0.0 |  0.04
Output  | 4.9533e-05 | 4.9533e-05 | 4.9533e-05 |   0.0 |  0.00
Modify  | 0.12305    | 0.12305    | 0.12305    |   0.0 |  0.20
Other   |            | 0.01166    |            |       |  0.02

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

Total # of neighbors = 279750
Ave neighs/atom = 69.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 = 312.847447288546, Press = 0.116431988324033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13108.107     -13108.107     -13270.132     -13270.132      313.44887      313.44887      67406.993      67406.993      515.22291      515.22291    
     56000  -13110.82      -13110.82      -13270.052     -13270.052      308.04501      308.04501      67430.065      67430.065      180.47192      180.47192    
Loop time of 61.1031 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.973 hours/ns, 16.366 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    | 60.946     | 60.946     | 60.946     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022769   | 0.022769   | 0.022769   |   0.0 |  0.04
Output  | 8.0331e-05 | 8.0331e-05 | 8.0331e-05 |   0.0 |  0.00
Modify  | 0.12295    | 0.12295    | 0.12295    |   0.0 |  0.20
Other   |            | 0.01098    |            |       |  0.02

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

Total # of neighbors = 281014
Ave neighs/atom = 70.2535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.841863169639, Press = -0.542771175752717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13110.82      -13110.82      -13270.052     -13270.052      308.04501      308.04501      67430.065      67430.065      180.47192      180.47192    
     57000  -13107.742     -13107.742     -13272.965     -13272.965      319.63426      319.63426      67478.365      67478.365     -489.53215     -489.53215    
Loop time of 61.2977 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.027 hours/ns, 16.314 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    | 61.139     | 61.139     | 61.139     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023295   | 0.023295   | 0.023295   |   0.0 |  0.04
Output  | 4.9352e-05 | 4.9352e-05 | 4.9352e-05 |   0.0 |  0.00
Modify  | 0.12382    | 0.12382    | 0.12382    |   0.0 |  0.20
Other   |            | 0.01101    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 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:       281002 ave      281002 max      281002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281002
Ave neighs/atom = 70.2505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.858893858946, Press = -0.25610228050709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13107.742     -13107.742     -13272.965     -13272.965      319.63426      319.63426      67478.365      67478.365     -489.53215     -489.53215    
     58000  -13107.919     -13107.919     -13271.697     -13271.697      316.83893      316.83893      67417.124      67417.124      265.73104      265.73104    
Loop time of 61.1656 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.990 hours/ns, 16.349 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    | 61.01      | 61.01      | 61.01      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022252   | 0.022252   | 0.022252   |   0.0 |  0.04
Output  | 4.8311e-05 | 4.8311e-05 | 4.8311e-05 |   0.0 |  0.00
Modify  | 0.12236    | 0.12236    | 0.12236    |   0.0 |  0.20
Other   |            | 0.01107    |            |       |  0.02

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

Total # of neighbors = 280470
Ave neighs/atom = 70.1175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.877680161346, Press = 0.155462264787005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13107.919     -13107.919     -13271.697     -13271.697      316.83893      316.83893      67417.124      67417.124      265.73104      265.73104    
     59000  -13106.068     -13106.068     -13267.715     -13267.715      312.71686      312.71686      67372.694      67372.694      1071.9146      1071.9146    
Loop time of 61.0851 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.968 hours/ns, 16.371 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    | 60.931     | 60.931     | 60.931     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021934   | 0.021934   | 0.021934   |   0.0 |  0.04
Output  | 4.8431e-05 | 4.8431e-05 | 4.8431e-05 |   0.0 |  0.00
Modify  | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.20
Other   |            | 0.01042    |            |       |  0.02

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

Total # of neighbors = 280996
Ave neighs/atom = 70.249
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.91671463011, Press = -0.824661176724652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13106.068     -13106.068     -13267.715     -13267.715      312.71686      312.71686      67372.694      67372.694      1071.9146      1071.9146    
     60000  -13110.641     -13110.641     -13270.199     -13270.199      308.67638      308.67638      67522.172      67522.172     -847.7536      -847.7536     
Loop time of 61.2797 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.022 hours/ns, 16.319 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    | 61.125     | 61.125     | 61.125     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021902   | 0.021902   | 0.021902   |   0.0 |  0.04
Output  | 5.1416e-05 | 5.1416e-05 | 5.1416e-05 |   0.0 |  0.00
Modify  | 0.12238    | 0.12238    | 0.12238    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 281408
Ave neighs/atom = 70.352
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.944992966359, Press = -0.492692506943852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13110.641     -13110.641     -13270.199     -13270.199      308.67638      308.67638      67522.172      67522.172     -847.7536      -847.7536     
     61000  -13112.083     -13112.083     -13272.731     -13272.731      310.78481      310.78481      67447.937      67447.937     -204.29722     -204.29722    
Loop time of 61.2079 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 17.002 hours/ns, 16.338 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    | 61.054     | 61.054     | 61.054     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021788   | 0.021788   | 0.021788   |   0.0 |  0.04
Output  | 5.4142e-05 | 5.4142e-05 | 5.4142e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 280282
Ave neighs/atom = 70.0705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.969097820589, Press = 0.237167818829462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13112.083     -13112.083     -13272.731     -13272.731      310.78481      310.78481      67447.937      67447.937     -204.29722     -204.29722    
     62000  -13107.331     -13107.331     -13270.235     -13270.235      315.14843      315.14843      67405.382      67405.382      536.06751      536.06751    
Loop time of 61.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 16.992 hours/ns, 16.348 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    | 61.015     | 61.015     | 61.015     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0222     | 0.0222     | 0.0222     |   0.0 |  0.04
Output  | 4.7078e-05 | 4.7078e-05 | 4.7078e-05 |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 280974
Ave neighs/atom = 70.2435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.942589582824, Press = -0.197766020739973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13107.331     -13107.331     -13270.235     -13270.235      315.14843      315.14843      67405.382      67405.382      536.06751      536.06751    
     63000  -13110.757     -13110.757     -13273.319     -13273.319      314.48863      314.48863      67464.382      67464.382     -438.57743     -438.57743    
Loop time of 61.0665 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.963 hours/ns, 16.376 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    | 60.912     | 60.912     | 60.912     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02189    | 0.02189    | 0.02189    |   0.0 |  0.04
Output  | 5.1116e-05 | 5.1116e-05 | 5.1116e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.20
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 281182
Ave neighs/atom = 70.2955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 312.94076439823, Press = -0.373449671196007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13110.757     -13110.757     -13273.319     -13273.319      314.48863      314.48863      67464.382      67464.382     -438.57743     -438.57743    
     64000  -13105.404     -13105.404     -13269.712     -13269.712      317.86596      317.86596      67468.971      67468.971     -172.65678     -172.65678    
Loop time of 60.9009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.917 hours/ns, 16.420 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    | 60.747     | 60.747     | 60.747     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021967   | 0.021967   | 0.021967   |   0.0 |  0.04
Output  | 4.9282e-05 | 4.9282e-05 | 4.9282e-05 |   0.0 |  0.00
Modify  | 0.12195    | 0.12195    | 0.12195    |   0.0 |  0.20
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 280510
Ave neighs/atom = 70.1275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67445.7186554443

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0