# 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.045353233814239*${_u_distance}
variable latticeconst_converted equal 4.045353233814239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04535323381424
Lattice spacing in x,y,z = 4.0453532 4.0453532 4.0453532
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.453532 40.453532 40.453532)
  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.453532 40.453532 40.453532)
  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_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_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 66201.7315006764    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*1*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66201.7315006764*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66201.7315006764 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_461927113651_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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      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   
         0  -13267.948     -13267.948     -13440.157     -13440.157      333.15         333.15         66201.732      66201.732      2778.4759      2778.4759    
      1000  -13080.424     -13080.424     -13248.345     -13248.345      324.855        324.855        67631.561      67631.561     -827.21279     -827.21279    
Loop time of 49.1423 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.758 ns/day, 13.651 hours/ns, 20.349 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.991     | 48.991     | 48.991     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022386   | 0.022386   | 0.022386   |   0.0 |  0.05
Output  | 0.00016116 | 0.00016116 | 0.00016116 |   0.0 |  0.00
Modify  | 0.11833    | 0.11833    | 0.11833    |   0.0 |  0.24
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:       216000 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13080.424     -13080.424     -13248.345     -13248.345      324.855        324.855        67631.561      67631.561     -827.21279     -827.21279    
      2000  -13096.797     -13096.797     -13261.529     -13261.529      318.68482      318.68482      67434.684      67434.684      500.02231      500.02231    
Loop time of 53.9797 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.601 ns/day, 14.994 hours/ns, 18.525 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    | 53.831     | 53.831     | 53.831     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021107   | 0.021107   | 0.021107   |   0.0 |  0.04
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.11759    | 0.11759    | 0.11759    |   0.0 |  0.22
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 224652
Ave neighs/atom = 56.163
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13096.797     -13096.797     -13261.529     -13261.529      318.68482      318.68482      67434.684      67434.684      500.02231      500.02231    
      3000  -13085.038     -13085.038     -13257.335     -13257.335      333.32004      333.32004      67499.82       67499.82       184.08067      184.08067    
Loop time of 54.1443 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.040 hours/ns, 18.469 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    | 53.996     | 53.996     | 53.996     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02103    | 0.02103    | 0.02103    |   0.0 |  0.04
Output  | 5.0054e-05 | 5.0054e-05 | 5.0054e-05 |   0.0 |  0.00
Modify  | 0.11758    | 0.11758    | 0.11758    |   0.0 |  0.22
Other   |            | 0.01009    |            |       |  0.02

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

Total # of neighbors = 224640
Ave neighs/atom = 56.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13085.038     -13085.038     -13257.335     -13257.335      333.32004      333.32004      67499.82       67499.82       184.08067      184.08067    
      4000  -13094.702     -13094.702     -13266.289     -13266.289      331.94698      331.94698      67482.007      67482.007     -90.014303     -90.014303    
Loop time of 54.159 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.044 hours/ns, 18.464 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    | 54.01      | 54.01      | 54.01      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021134   | 0.021134   | 0.021134   |   0.0 |  0.04
Output  | 5.0706e-05 | 5.0706e-05 | 5.0706e-05 |   0.0 |  0.00
Modify  | 0.1174     | 0.1174     | 0.1174     |   0.0 |  0.22
Other   |            | 0.01006    |            |       |  0.02

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

Total # of neighbors = 224294
Ave neighs/atom = 56.0735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13094.702     -13094.702     -13266.289     -13266.289      331.94698      331.94698      67482.007      67482.007     -90.014303     -90.014303    
      5000  -13085.907     -13085.907     -13260.1       -13260.1        336.98723      336.98723      67486.842      67486.842      109.02485      109.02485    
Loop time of 54.1255 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.035 hours/ns, 18.476 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    | 53.976     | 53.976     | 53.976     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021339   | 0.021339   | 0.021339   |   0.0 |  0.04
Output  | 4.1779e-05 | 4.1779e-05 | 4.1779e-05 |   0.0 |  0.00
Modify  | 0.1178     | 0.1178     | 0.1178     |   0.0 |  0.22
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 224156
Ave neighs/atom = 56.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 339.66738663038, Press = -38.0532874097017
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13085.907     -13085.907     -13260.1       -13260.1        336.98723      336.98723      67486.842      67486.842      109.02485      109.02485    
      6000  -13094.228     -13094.228     -13260.83      -13260.83       322.30295      322.30295      67515.472      67515.472     -239.70092     -239.70092    
Loop time of 54.3478 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.097 hours/ns, 18.400 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    | 54.195     | 54.195     | 54.195     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021076   | 0.021076   | 0.021076   |   0.0 |  0.04
Output  | 4.7138e-05 | 4.7138e-05 | 4.7138e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.22
Other   |            | 0.01013    |            |       |  0.02

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

Total # of neighbors = 224550
Ave neighs/atom = 56.1375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974679680044, Press = -5.60247943520326
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13094.228     -13094.228     -13260.83      -13260.83       322.30295      322.30295      67515.472      67515.472     -239.70092     -239.70092    
      7000  -13087.511     -13087.511     -13260.71      -13260.71       335.06489      335.06489      67385.077      67385.077      1238.6922      1238.6922    
Loop time of 54.1798 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.050 hours/ns, 18.457 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    | 54.027     | 54.027     | 54.027     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021114   | 0.021114   | 0.021114   |   0.0 |  0.04
Output  | 4.7338e-05 | 4.7338e-05 | 4.7338e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.22
Other   |            | 0.01009    |            |       |  0.02

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

Total # of neighbors = 224326
Ave neighs/atom = 56.0815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.447516577832, Press = 5.44777521226239
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13087.511     -13087.511     -13260.71      -13260.71       335.06489      335.06489      67385.077      67385.077      1238.6922      1238.6922    
      8000  -13089.311     -13089.311     -13260.198     -13260.198      330.59386      330.59386      67645.66       67645.66      -1542.2571     -1542.2571    
Loop time of 54.3359 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.093 hours/ns, 18.404 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    | 54.183     | 54.183     | 54.183     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021305   | 0.021305   | 0.021305   |   0.0 |  0.04
Output  | 5.3861e-05 | 5.3861e-05 | 5.3861e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.22
Other   |            | 0.0101     |            |       |  0.02

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

Total # of neighbors = 224594
Ave neighs/atom = 56.1485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.189304112667, Press = 3.27978702076705
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13089.311     -13089.311     -13260.198     -13260.198      330.59386      330.59386      67645.66       67645.66      -1542.2571     -1542.2571    
      9000  -13092.702     -13092.702     -13265.628     -13265.628      334.53806      334.53806      67419.877      67419.877      577.40169      577.40169    
Loop time of 54.1211 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.034 hours/ns, 18.477 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    | 53.968     | 53.968     | 53.968     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021186   | 0.021186   | 0.021186   |   0.0 |  0.04
Output  | 4.78e-05   | 4.78e-05   | 4.78e-05   |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  0.22
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 223722
Ave neighs/atom = 55.9305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.690719442017, Press = -7.39192694236926
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13092.702     -13092.702     -13265.628     -13265.628      334.53806      334.53806      67419.877      67419.877      577.40169      577.40169    
     10000  -13088.665     -13088.665     -13260.181     -13260.181      331.80974      331.80974      67501.446      67501.446     -20.715247     -20.715247    
Loop time of 54.3182 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.088 hours/ns, 18.410 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    | 54.165     | 54.165     | 54.165     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021028   | 0.021028   | 0.021028   |   0.0 |  0.04
Output  | 4.5155e-05 | 4.5155e-05 | 4.5155e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.22
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 224202
Ave neighs/atom = 56.0505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.390403016138, Press = 4.05275202340763
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13088.665     -13088.665     -13260.181     -13260.181      331.80974      331.80974      67501.446      67501.446     -20.715247     -20.715247    
     11000  -13093.336     -13093.336     -13263.576     -13263.576      329.34248      329.34248      67493.564      67493.564     -179.11764     -179.11764    
Loop time of 54.2822 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.078 hours/ns, 18.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    | 54.129     | 54.129     | 54.129     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 4.4334e-05 | 4.4334e-05 | 4.4334e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.22
Other   |            | 0.01012    |            |       |  0.02

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

Total # of neighbors = 224238
Ave neighs/atom = 56.0595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.003531588959, Press = -1.42229729289801
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13093.336     -13093.336     -13263.576     -13263.576      329.34248      329.34248      67493.564      67493.564     -179.11764     -179.11764    
     12000  -13089.719     -13089.719     -13263.006     -13263.006      335.23588      335.23588      67470.618      67470.618      156.93686      156.93686    
Loop time of 54.2771 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.077 hours/ns, 18.424 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    | 54.125     | 54.125     | 54.125     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021021   | 0.021021   | 0.021021   |   0.0 |  0.04
Output  | 3.9764e-05 | 3.9764e-05 | 3.9764e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.22
Other   |            | 0.01011    |            |       |  0.02

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

Total # of neighbors = 224152
Ave neighs/atom = 56.038
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.940511764033, Press = 2.10654469090265
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13089.719     -13089.719     -13263.006     -13263.006      335.23588      335.23588      67470.618      67470.618      156.93686      156.93686    
     13000  -13091.233     -13091.233     -13264.267     -13264.267      334.74603      334.74603      67566.414      67566.414     -978.69842     -978.69842    
Loop time of 54.2853 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.079 hours/ns, 18.421 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    | 54.132     | 54.132     | 54.132     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021557   | 0.021557   | 0.021557   |   0.0 |  0.04
Output  | 8.1273e-05 | 8.1273e-05 | 8.1273e-05 |   0.0 |  0.00
Modify  | 0.12165    | 0.12165    | 0.12165    |   0.0 |  0.22
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 224318
Ave neighs/atom = 56.0795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.704385798444, Press = -4.70992126791653
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13091.233     -13091.233     -13264.267     -13264.267      334.74603      334.74603      67566.414      67566.414     -978.69842     -978.69842    
     14000  -13090.056     -13090.056     -13261.22      -13261.22       331.13002      331.13002      67355.039      67355.039      1371.2019      1371.2019    
Loop time of 54.2763 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.077 hours/ns, 18.424 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    | 54.124     | 54.124     | 54.124     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021236   | 0.021236   | 0.021236   |   0.0 |  0.04
Output  | 4.8201e-05 | 4.8201e-05 | 4.8201e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.22
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 224056
Ave neighs/atom = 56.014
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.670922139722, Press = 3.57764188986335
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13090.056     -13090.056     -13261.22      -13261.22       331.13002      331.13002      67355.039      67355.039      1371.2019      1371.2019    
     15000  -13090.49      -13090.49      -13259.981     -13259.981      327.89248      327.89248      67580.354      67580.354     -848.87661     -848.87661    
Loop time of 54.6301 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.582 ns/day, 15.175 hours/ns, 18.305 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    | 54.468     | 54.468     | 54.468     |   0.0 | 99.70
Neigh   | 0.0086343  | 0.0086343  | 0.0086343  |   0.0 |  0.02
Comm    | 0.021795   | 0.021795   | 0.021795   |   0.0 |  0.04
Output  | 4.7429e-05 | 4.7429e-05 | 4.7429e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.22
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 224160
Ave neighs/atom = 56.04
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.687568809283, Press = 0.0621699405447765
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13090.49      -13090.49      -13259.981     -13259.981      327.89248      327.89248      67580.354      67580.354     -848.87661     -848.87661    
     16000  -13084.405     -13084.405     -13258.344     -13258.344      336.49683      336.49683      67442.084      67442.084      734.62796      734.62796    
Loop time of 54.1509 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.042 hours/ns, 18.467 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    | 53.998     | 53.998     | 53.998     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021188   | 0.021188   | 0.021188   |   0.0 |  0.04
Output  | 4.8371e-05 | 4.8371e-05 | 4.8371e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.22
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 224292
Ave neighs/atom = 56.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 = 332.922345313484, Press = -1.37385069252405
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13084.405     -13084.405     -13258.344     -13258.344      336.49683      336.49683      67442.084      67442.084      734.62796      734.62796    
     17000  -13087.669     -13087.669     -13264.502     -13264.502      342.09397      342.09397      67512.639      67512.639     -285.72404     -285.72404    
Loop time of 54.2806 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.078 hours/ns, 18.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    | 54.128     | 54.128     | 54.128     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021433   | 0.021433   | 0.021433   |   0.0 |  0.04
Output  | 4.817e-05  | 4.817e-05  | 4.817e-05  |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.22
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 224662
Ave neighs/atom = 56.1655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.900873463255, Press = 2.43795142602949
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13087.669     -13087.669     -13264.502     -13264.502      342.09397      342.09397      67512.639      67512.639     -285.72404     -285.72404    
     18000  -13094.9       -13094.9       -13262.732     -13262.732      324.68316      324.68316      67490.503      67490.503     -70.837956     -70.837956    
Loop time of 54.1867 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.052 hours/ns, 18.455 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    | 54.034     | 54.034     | 54.034     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021119   | 0.021119   | 0.021119   |   0.0 |  0.04
Output  | 4.804e-05  | 4.804e-05  | 4.804e-05  |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.22
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 224126
Ave neighs/atom = 56.0315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.819053295854, Press = -1.2266951474865
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13094.9       -13094.9       -13262.732     -13262.732      324.68316      324.68316      67490.503      67490.503     -70.837956     -70.837956    
     19000  -13088.722     -13088.722     -13262.56      -13262.56       336.30126      336.30126      67449.808      67449.808      418.37675      418.37675    
Loop time of 54.2075 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.058 hours/ns, 18.448 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    | 54.055     | 54.055     | 54.055     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021289   | 0.021289   | 0.021289   |   0.0 |  0.04
Output  | 4.8251e-05 | 4.8251e-05 | 4.8251e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.22
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 224272
Ave neighs/atom = 56.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.757210264583, Press = 0.734208041405447
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13088.722     -13088.722     -13262.56      -13262.56       336.30126      336.30126      67449.808      67449.808      418.37675      418.37675    
     20000  -13096.368     -13096.368     -13265.007     -13265.007      326.24282      326.24282      67511.692      67511.692     -407.13077     -407.13077    
Loop time of 54.3514 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.098 hours/ns, 18.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    | 54.199     | 54.199     | 54.199     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021232   | 0.021232   | 0.021232   |   0.0 |  0.04
Output  | 4.7168e-05 | 4.7168e-05 | 4.7168e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.22
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 224602
Ave neighs/atom = 56.1505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.627189842269, Press = 0.269523992986709
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13096.368     -13096.368     -13265.007     -13265.007      326.24282      326.24282      67511.692      67511.692     -407.13077     -407.13077    
     21000  -13090.829     -13090.829     -13264.659     -13264.659      336.28669      336.28669      67428.386      67428.386      484.60232      484.60232    
Loop time of 54.1056 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.597 ns/day, 15.029 hours/ns, 18.482 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    | 53.953     | 53.953     | 53.953     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021474   | 0.021474   | 0.021474   |   0.0 |  0.04
Output  | 4.4433e-05 | 4.4433e-05 | 4.4433e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.22
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 224036
Ave neighs/atom = 56.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.640496543336, Press = -0.34219113128721
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13090.829     -13090.829     -13264.659     -13264.659      336.28669      336.28669      67428.386      67428.386      484.60232      484.60232    
     22000  -13094.379     -13094.379     -13266.572     -13266.572      333.11918      333.11918      67536.571      67536.571     -765.52525     -765.52525    
Loop time of 54.1101 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.597 ns/day, 15.031 hours/ns, 18.481 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    | 53.957     | 53.957     | 53.957     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021282   | 0.021282   | 0.021282   |   0.0 |  0.04
Output  | 3.6318e-05 | 3.6318e-05 | 3.6318e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.22
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 224410
Ave neighs/atom = 56.1025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.631311427878, Press = 1.12836932825528
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13094.379     -13094.379     -13266.572     -13266.572      333.11918      333.11918      67536.571      67536.571     -765.52525     -765.52525    
     23000  -13088.165     -13088.165     -13263.002     -13263.002      338.23266      338.23266      67447.04       67447.04       421.0801       421.0801     
Loop time of 54.1226 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.034 hours/ns, 18.477 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    | 53.97      | 53.97      | 53.97      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021288   | 0.021288   | 0.021288   |   0.0 |  0.04
Output  | 4.8271e-05 | 4.8271e-05 | 4.8271e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224052
Ave neighs/atom = 56.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.618700803416, Press = -2.8519870151591
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13088.165     -13088.165     -13263.002     -13263.002      338.23266      338.23266      67447.04       67447.04       421.0801       421.0801     
     24000  -13100.084     -13100.084     -13269.742     -13269.742      328.21355      328.21355      67428.784      67428.784      186.92051      186.92051    
Loop time of 54.3212 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.089 hours/ns, 18.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    | 54.169     | 54.169     | 54.169     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0212     | 0.0212     | 0.0212     |   0.0 |  0.04
Output  | 4.805e-05  | 4.805e-05  | 4.805e-05  |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.22
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 224506
Ave neighs/atom = 56.1265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.553427514446, Press = 2.43283396183743
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13100.084     -13100.084     -13269.742     -13269.742      328.21355      328.21355      67428.784      67428.784      186.92051      186.92051    
     25000  -13089.982     -13089.982     -13262.189     -13262.189      333.14612      333.14612      67546.507      67546.507     -631.86891     -631.86891    
Loop time of 54.2209 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.061 hours/ns, 18.443 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    | 54.068     | 54.068     | 54.068     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021359   | 0.021359   | 0.021359   |   0.0 |  0.04
Output  | 4.7539e-05 | 4.7539e-05 | 4.7539e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.22
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 224142
Ave neighs/atom = 56.0355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.529726413243, Press = -1.33019717717229
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13089.982     -13089.982     -13262.189     -13262.189      333.14612      333.14612      67546.507      67546.507     -631.86891     -631.86891    
     26000  -13092.294     -13092.294     -13262.745     -13262.745      329.74842      329.74842      67392.869      67392.869      961.839        961.839      
Loop time of 54.2734 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.076 hours/ns, 18.425 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    | 54.121     | 54.121     | 54.121     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021234   | 0.021234   | 0.021234   |   0.0 |  0.04
Output  | 4.9142e-05 | 4.9142e-05 | 4.9142e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.22
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 224272
Ave neighs/atom = 56.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.542019568809, Press = 1.01611696254183
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13092.294     -13092.294     -13262.745     -13262.745      329.74842      329.74842      67392.869      67392.869      961.839        961.839      
     27000  -13087.774     -13087.774     -13262.169     -13262.169      337.37851      337.37851      67590.548      67590.548     -1021.3675     -1021.3675    
Loop time of 54.3145 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.087 hours/ns, 18.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    | 54.162     | 54.162     | 54.162     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021318   | 0.021318   | 0.021318   |   0.0 |  0.04
Output  | 4.9032e-05 | 4.9032e-05 | 4.9032e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.22
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 224948
Ave neighs/atom = 56.237
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.571621564283, Press = -0.0842140131074114
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13087.774     -13087.774     -13262.169     -13262.169      337.37851      337.37851      67590.548      67590.548     -1021.3675     -1021.3675    
     28000  -13093.935     -13093.935     -13266.602     -13266.602      334.03614      334.03614      67394.659      67394.659      746.72414      746.72414    
Loop time of 54.2506 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.070 hours/ns, 18.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    | 54.098     | 54.098     | 54.098     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021322   | 0.021322   | 0.021322   |   0.0 |  0.04
Output  | 4.7089e-05 | 4.7089e-05 | 4.7089e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.22
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 224166
Ave neighs/atom = 56.0415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.563550552218, Press = -0.2802384796163
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13093.935     -13093.935     -13266.602     -13266.602      334.03614      334.03614      67394.659      67394.659      746.72414      746.72414    
     29000  -13086.959     -13086.959     -13261.684     -13261.684      338.01807      338.01807      67528.561      67528.561     -407.26567     -407.26567    
Loop time of 54.2094 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.058 hours/ns, 18.447 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    | 54.056     | 54.056     | 54.056     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02136    | 0.02136    | 0.02136    |   0.0 |  0.04
Output  | 4.8451e-05 | 4.8451e-05 | 4.8451e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.22
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 224528
Ave neighs/atom = 56.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.561835556371, Press = 0.440925700287497
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13086.959     -13086.959     -13261.684     -13261.684      338.01807      338.01807      67528.561      67528.561     -407.26567     -407.26567    
     30000  -13096.378     -13096.378     -13264.532     -13264.532      325.30518      325.30518      67458.882      67458.882      54.679577      54.679577    
Loop time of 54.6365 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.581 ns/day, 15.177 hours/ns, 18.303 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    | 54.474     | 54.474     | 54.474     |   0.0 | 99.70
Neigh   | 0.0087361  | 0.0087361  | 0.0087361  |   0.0 |  0.02
Comm    | 0.021814   | 0.021814   | 0.021814   |   0.0 |  0.04
Output  | 4.7479e-05 | 4.7479e-05 | 4.7479e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.22
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 224526
Ave neighs/atom = 56.1315
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.511053364244, Press = -0.184636946170163
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13096.378     -13096.378     -13264.532     -13264.532      325.30518      325.30518      67458.882      67458.882      54.679577      54.679577    
     31000  -13086.275     -13086.275     -13257.511     -13257.511      331.26763      331.26763      67504.85       67504.85       4.7138979      4.7138979    
Loop time of 54.1807 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.050 hours/ns, 18.457 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    | 54.028     | 54.028     | 54.028     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021415   | 0.021415   | 0.021415   |   0.0 |  0.04
Output  | 4.6066e-05 | 4.6066e-05 | 4.6066e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.22
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 224128
Ave neighs/atom = 56.032
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.528597978536, Press = 0.319748553972483
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13086.275     -13086.275     -13257.511     -13257.511      331.26763      331.26763      67504.85       67504.85       4.7138979      4.7138979    
     32000  -13094.061     -13094.061     -13264.033     -13264.033      328.8219       328.8219       67479.231      67479.231     -24.896861     -24.896861    
Loop time of 54.3409 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.095 hours/ns, 18.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    | 54.188     | 54.188     | 54.188     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021353   | 0.021353   | 0.021353   |   0.0 |  0.04
Output  | 3.6839e-05 | 3.6839e-05 | 3.6839e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224594
Ave neighs/atom = 56.1485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.549806871213, Press = -0.77653609022362
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13094.061     -13094.061     -13264.033     -13264.033      328.8219       328.8219       67479.231      67479.231     -24.896861     -24.896861    
     33000  -13088.328     -13088.328     -13261.677     -13261.677      335.35493      335.35493      67453.483      67453.483      457.01356      457.01356    
Loop time of 54.1556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.043 hours/ns, 18.465 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    | 54.003     | 54.003     | 54.003     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021213   | 0.021213   | 0.021213   |   0.0 |  0.04
Output  | 3.6388e-05 | 3.6388e-05 | 3.6388e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.22
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 224018
Ave neighs/atom = 56.0045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.519740944546, Press = 1.41512325125859
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13088.328     -13088.328     -13261.677     -13261.677      335.35493      335.35493      67453.483      67453.483      457.01356      457.01356    
     34000  -13095.41      -13095.41      -13263.766     -13263.766      325.69661      325.69661      67554.731      67554.731     -804.34897     -804.34897    
Loop time of 54.3621 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.589 ns/day, 15.101 hours/ns, 18.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    | 54.209     | 54.209     | 54.209     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021264   | 0.021264   | 0.021264   |   0.0 |  0.04
Output  | 3.721e-05  | 3.721e-05  | 3.721e-05  |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.22
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 224462
Ave neighs/atom = 56.1155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.516848895903, Press = -1.33259219900544
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13095.41      -13095.41      -13263.766     -13263.766      325.69661      325.69661      67554.731      67554.731     -804.34897     -804.34897    
     35000  -13086.851     -13086.851     -13259.387     -13259.387      333.78199      333.78199      67410.93       67410.93       990.35948      990.35948    
Loop time of 54.2197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.061 hours/ns, 18.443 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    | 54.067     | 54.067     | 54.067     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021294   | 0.021294   | 0.021294   |   0.0 |  0.04
Output  | 4.8441e-05 | 4.8441e-05 | 4.8441e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 223914
Ave neighs/atom = 55.9785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.511197675111, Press = 0.412664937223385
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13086.851     -13086.851     -13259.387     -13259.387      333.78199      333.78199      67410.93       67410.93       990.35948      990.35948    
     36000  -13092.061     -13092.061     -13263.44      -13263.44       331.54325      331.54325      67529.298      67529.298     -584.91148     -584.91148    
Loop time of 54.2809 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.078 hours/ns, 18.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    | 54.128     | 54.128     | 54.128     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021105   | 0.021105   | 0.021105   |   0.0 |  0.04
Output  | 4.8481e-05 | 4.8481e-05 | 4.8481e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224886
Ave neighs/atom = 56.2215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.560956421132, Press = 0.0282122741512132
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13092.061     -13092.061     -13263.44      -13263.44       331.54325      331.54325      67529.298      67529.298     -584.91148     -584.91148    
     37000  -13087.328     -13087.328     -13261.877     -13261.877      337.6779       337.6779       67446.12       67446.12       404.55659      404.55659    
Loop time of 54.1699 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.047 hours/ns, 18.460 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    | 54.017     | 54.017     | 54.017     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021294   | 0.021294   | 0.021294   |   0.0 |  0.04
Output  | 4.7519e-05 | 4.7519e-05 | 4.7519e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.22
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 224098
Ave neighs/atom = 56.0245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.616672877356, Press = -0.233183341174319
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13087.328     -13087.328     -13261.877     -13261.877      337.6779       337.6779       67446.12       67446.12       404.55659      404.55659    
     38000  -13084.595     -13084.595     -13258.202     -13258.202      335.85544      335.85544      67539.634      67539.634     -371.17359     -371.17359    
Loop time of 54.3129 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.087 hours/ns, 18.412 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    | 54.16      | 54.16      | 54.16      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021197   | 0.021197   | 0.021197   |   0.0 |  0.04
Output  | 4.8911e-05 | 4.8911e-05 | 4.8911e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.22
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 224606
Ave neighs/atom = 56.1515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.637273390217, Press = 0.387881140953052
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13084.595     -13084.595     -13258.202     -13258.202      335.85544      335.85544      67539.634      67539.634     -371.17359     -371.17359    
     39000  -13092.169     -13092.169     -13263.616     -13263.616      331.67468      331.67468      67447.948      67447.948      276.785        276.785      
Loop time of 54.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.071 hours/ns, 18.431 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    | 54.105     | 54.105     | 54.105     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020914   | 0.020914   | 0.020914   |   0.0 |  0.04
Output  | 5.5685e-05 | 5.5685e-05 | 5.5685e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.22
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 224432
Ave neighs/atom = 56.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.694587610169, Press = -1.90276151425692
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13092.169     -13092.169     -13263.616     -13263.616      331.67468      331.67468      67447.948      67447.948      276.785        276.785      
     40000  -13085.65      -13085.65      -13263.012     -13263.012      343.11962      343.11962      67453.103      67453.103      385.27976      385.27976    
Loop time of 54.2228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.062 hours/ns, 18.442 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    | 54.07      | 54.07      | 54.07      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021366   | 0.021366   | 0.021366   |   0.0 |  0.04
Output  | 5.0976e-05 | 5.0976e-05 | 5.0976e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.22
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 224478
Ave neighs/atom = 56.1195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.740815644314, Press = 1.55885361147833
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13085.65      -13085.65      -13263.012     -13263.012      343.11962      343.11962      67453.103      67453.103      385.27976      385.27976    
     41000  -13089.095     -13089.095     -13259.948     -13259.948      330.52661      330.52661      67536.263      67536.263     -415.63609     -415.63609    
Loop time of 54.2561 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.071 hours/ns, 18.431 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    | 54.104     | 54.104     | 54.104     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021016   | 0.021016   | 0.021016   |   0.0 |  0.04
Output  | 5.9682e-05 | 5.9682e-05 | 5.9682e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224792
Ave neighs/atom = 56.198
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.723400554249, Press = -0.538767451464872
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13089.095     -13089.095     -13259.948     -13259.948      330.52661      330.52661      67536.263      67536.263     -415.63609     -415.63609    
     42000  -13097.273     -13097.273     -13265.954     -13265.954      326.32419      326.32419      67408.734      67408.734      586.00704      586.00704    
Loop time of 54.2185 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.061 hours/ns, 18.444 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    | 54.065     | 54.065     | 54.065     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021292   | 0.021292   | 0.021292   |   0.0 |  0.04
Output  | 4.3772e-05 | 4.3772e-05 | 4.3772e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.22
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 224346
Ave neighs/atom = 56.0865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.710519537078, Press = 0.196398982883554
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13097.273     -13097.273     -13265.954     -13265.954      326.32419      326.32419      67408.734      67408.734      586.00704      586.00704    
     43000  -13088.5       -13088.5       -13260.103     -13260.103      331.97617      331.97617      67544.753      67544.753     -474.38848     -474.38848    
Loop time of 54.2063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.057 hours/ns, 18.448 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    | 54.054     | 54.054     | 54.054     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021202   | 0.021202   | 0.021202   |   0.0 |  0.04
Output  | 3.6599e-05 | 3.6599e-05 | 3.6599e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224400
Ave neighs/atom = 56.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.682029662303, Press = 0.0850397546813992
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13088.5       -13088.5       -13260.103     -13260.103      331.97617      331.97617      67544.753      67544.753     -474.38848     -474.38848    
     44000  -13095.111     -13095.111     -13262.391     -13262.391      323.61585      323.61585      67368.993      67368.993      1114.2168      1114.2168    
Loop time of 54.1266 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.035 hours/ns, 18.475 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    | 53.974     | 53.974     | 53.974     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021289   | 0.021289   | 0.021289   |   0.0 |  0.04
Output  | 4.7769e-05 | 4.7769e-05 | 4.7769e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224314
Ave neighs/atom = 56.0785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.652210160864, Press = -0.318507493751136
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13095.111     -13095.111     -13262.391     -13262.391      323.61585      323.61585      67368.993      67368.993      1114.2168      1114.2168    
     45000  -13090.96      -13090.96      -13261.783     -13261.783      330.46831      330.46831      67582.731      67582.731     -1031.3512     -1031.3512    
Loop time of 54.2592 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.072 hours/ns, 18.430 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    | 54.106     | 54.106     | 54.106     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021215   | 0.021215   | 0.021215   |   0.0 |  0.04
Output  | 4.9242e-05 | 4.9242e-05 | 4.9242e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.22
Other   |            | 0.0102     |            |       |  0.02

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

Total # of neighbors = 224756
Ave neighs/atom = 56.189
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.681490495606, Press = 0.968971113500099
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13090.96      -13090.96      -13261.783     -13261.783      330.46831      330.46831      67582.731      67582.731     -1031.3512     -1031.3512    
     46000  -13087.576     -13087.576     -13259.362     -13259.362      332.33073      332.33073      67462.241      67462.241      353.85666      353.85666    
Loop time of 54.2014 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.056 hours/ns, 18.450 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    | 54.049     | 54.049     | 54.049     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02116    | 0.02116    | 0.02116    |   0.0 |  0.04
Output  | 5.2028e-05 | 5.2028e-05 | 5.2028e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.22
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 224206
Ave neighs/atom = 56.0515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.717716310829, Press = -0.869212771302644
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13087.576     -13087.576     -13259.362     -13259.362      332.33073      332.33073      67462.241      67462.241      353.85666      353.85666    
     47000  -13088.92      -13088.92      -13261.646     -13261.646      334.14955      334.14955      67455.723      67455.723      331.11566      331.11566    
Loop time of 54.2396 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.067 hours/ns, 18.437 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    | 54.087     | 54.087     | 54.087     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020813   | 0.020813   | 0.020813   |   0.0 |  0.04
Output  | 4.775e-05  | 4.775e-05  | 4.775e-05  |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.22
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 224890
Ave neighs/atom = 56.2225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.791828648126, Press = 0.515787659732902
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13088.92      -13088.92      -13261.646     -13261.646      334.14955      334.14955      67455.723      67455.723      331.11566      331.11566    
     48000  -13088.194     -13088.194     -13259.695     -13259.695      331.78158      331.78158      67524.164      67524.164     -338.67542     -338.67542    
Loop time of 54.1776 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.049 hours/ns, 18.458 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    | 54.025     | 54.025     | 54.025     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021349   | 0.021349   | 0.021349   |   0.0 |  0.04
Output  | 4.8511e-05 | 4.8511e-05 | 4.8511e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.22
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 224656
Ave neighs/atom = 56.164
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.798964932667, Press = -0.371377921599008
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13088.194     -13088.194     -13259.695     -13259.695      331.78158      331.78158      67524.164      67524.164     -338.67542     -338.67542    
     49000  -13092.429     -13092.429     -13264.602     -13264.602      333.07934      333.07934      67398.984      67398.984      763.73677      763.73677    
Loop time of 54.1938 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.594 ns/day, 15.054 hours/ns, 18.452 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    | 54.041     | 54.041     | 54.041     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021126   | 0.021126   | 0.021126   |   0.0 |  0.04
Output  | 5.6907e-05 | 5.6907e-05 | 5.6907e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.22
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 224614
Ave neighs/atom = 56.1535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.829261199618, Press = 0.360224671958709
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13092.429     -13092.429     -13264.602     -13264.602      333.07934      333.07934      67398.984      67398.984      763.73677      763.73677    
     50000  -13091.254     -13091.254     -13260.5       -13260.5        327.41795      327.41795      67668.96       67668.96      -1916.3766     -1916.3766    
Loop time of 54.2741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.076 hours/ns, 18.425 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    | 54.121     | 54.121     | 54.121     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021316   | 0.021316   | 0.021316   |   0.0 |  0.04
Output  | 5.0384e-05 | 5.0384e-05 | 5.0384e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.22
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 224808
Ave neighs/atom = 56.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.852285095778, Press = 0.00460027128701692
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13091.254     -13091.254     -13260.5       -13260.5        327.41795      327.41795      67668.96       67668.96      -1916.3766     -1916.3766    
     51000  -13089.242     -13089.242     -13260.304     -13260.304      330.93015      330.93015      67399.229      67399.229      955.17983      955.17983    
Loop time of 54.2698 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.075 hours/ns, 18.426 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    | 54.117     | 54.117     | 54.117     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021013   | 0.021013   | 0.021013   |   0.0 |  0.04
Output  | 4.9062e-05 | 4.9062e-05 | 4.9062e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.22
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 224130
Ave neighs/atom = 56.0325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.875282701494, Press = -0.282196320184041
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13089.242     -13089.242     -13260.304     -13260.304      330.93015      330.93015      67399.229      67399.229      955.17983      955.17983    
     52000  -13095.599     -13095.599     -13265.211     -13265.211      328.12418      328.12418      67496.354      67496.354     -319.25326     -319.25326    
Loop time of 54.1421 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.039 hours/ns, 18.470 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    | 53.989     | 53.989     | 53.989     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02142    | 0.02142    | 0.02142    |   0.0 |  0.04
Output  | 4.4052e-05 | 4.4052e-05 | 4.4052e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.22
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 224930
Ave neighs/atom = 56.2325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.832630529328, Press = 0.499698152450024
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13095.599     -13095.599     -13265.211     -13265.211      328.12418      328.12418      67496.354      67496.354     -319.25326     -319.25326    
     53000  -13091.133     -13091.133     -13262.727     -13262.727      331.96037      331.96037      67496.801      67496.801     -141.07993     -141.07993    
Loop time of 54.0761 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.598 ns/day, 15.021 hours/ns, 18.492 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    | 53.923     | 53.923     | 53.923     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021224   | 0.021224   | 0.021224   |   0.0 |  0.04
Output  | 3.6027e-05 | 3.6027e-05 | 3.6027e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.22
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 224182
Ave neighs/atom = 56.0455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.842163185992, Press = -0.437184850479213
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13091.133     -13091.133     -13262.727     -13262.727      331.96037      331.96037      67496.801      67496.801     -141.07993     -141.07993    
     54000  -13088.206     -13088.206     -13260.393     -13260.393      333.10827      333.10827      67454.012      67454.012      405.41096      405.41096    
Loop time of 54.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.045 hours/ns, 18.463 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    | 54.008     | 54.008     | 54.008     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021269   | 0.021269   | 0.021269   |   0.0 |  0.04
Output  | 5.0545e-05 | 5.0545e-05 | 5.0545e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.22
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 224308
Ave neighs/atom = 56.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.830108044293, Press = 0.568258963478355
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13088.206     -13088.206     -13260.393     -13260.393      333.10827      333.10827      67454.012      67454.012      405.41096      405.41096    
     55000  -13088.79      -13088.79      -13261.82      -13261.82       334.73857      334.73857      67637.294      67637.294     -1469.1243     -1469.1243    
Loop time of 54.2464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.068 hours/ns, 18.434 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    | 54.094     | 54.094     | 54.094     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021206   | 0.021206   | 0.021206   |   0.0 |  0.04
Output  | 5.5584e-05 | 5.5584e-05 | 5.5584e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.22
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 224754
Ave neighs/atom = 56.1885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.810000584616, Press = -0.850073208152534
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13088.79      -13088.79      -13261.82      -13261.82       334.73857      334.73857      67637.294      67637.294     -1469.1243     -1469.1243    
     56000  -13088.386     -13088.386     -13261.65      -13261.65       335.19024      335.19024      67355.231      67355.231      1479.6259      1479.6259    
Loop time of 54.1262 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.035 hours/ns, 18.475 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    | 53.973     | 53.973     | 53.973     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021404   | 0.021404   | 0.021404   |   0.0 |  0.04
Output  | 6.6815e-05 | 6.6815e-05 | 6.6815e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.22
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 224024
Ave neighs/atom = 56.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.81643262158, Press = 0.308612510092147
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13088.386     -13088.386     -13261.65      -13261.65       335.19024      335.19024      67355.231      67355.231      1479.6259      1479.6259    
     57000  -13091.492     -13091.492     -13262.271     -13262.271      330.38502      330.38502      67572.005      67572.005     -882.22967     -882.22967    
Loop time of 54.2886 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.080 hours/ns, 18.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    | 54.135     | 54.135     | 54.135     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021306   | 0.021306   | 0.021306   |   0.0 |  0.04
Output  | 6.0865e-05 | 6.0865e-05 | 6.0865e-05 |   0.0 |  0.00
Modify  | 0.1216     | 0.1216     | 0.1216     |   0.0 |  0.22
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 225030
Ave neighs/atom = 56.2575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863368135574, Press = 0.41173949488586
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13091.492     -13091.492     -13262.271     -13262.271      330.38502      330.38502      67572.005      67572.005     -882.22967     -882.22967    
     58000  -13087.471     -13087.471     -13260.645     -13260.645      335.01653      335.01653      67452.853      67452.853      497.7781       497.7781     
Loop time of 54.1477 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.596 ns/day, 15.041 hours/ns, 18.468 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    | 53.994     | 53.994     | 53.994     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021329   | 0.021329   | 0.021329   |   0.0 |  0.04
Output  | 6.0834e-05 | 6.0834e-05 | 6.0834e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.22
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 224058
Ave neighs/atom = 56.0145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.87369252936, Press = -0.395316965250289
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13087.471     -13087.471     -13260.645     -13260.645      335.01653      335.01653      67452.853      67452.853      497.7781       497.7781     
     59000  -13091.125     -13091.125     -13264.354     -13264.354      335.12247      335.12247      67487.478      67487.478     -137.94399     -137.94399    
Loop time of 54.3608 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.589 ns/day, 15.100 hours/ns, 18.396 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    | 54.208     | 54.208     | 54.208     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021196   | 0.021196   | 0.021196   |   0.0 |  0.04
Output  | 6.2978e-05 | 6.2978e-05 | 6.2978e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.22
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 224774
Ave neighs/atom = 56.1935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.883005501472, Press = 0.460117469320621
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13091.125     -13091.125     -13264.354     -13264.354      335.12247      335.12247      67487.478      67487.478     -137.94399     -137.94399    
     60000  -13093.904     -13093.904     -13260.738     -13260.738      322.75044      322.75044      67520.278      67520.278     -290.86337     -290.86337    
Loop time of 54.0926 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.597 ns/day, 15.026 hours/ns, 18.487 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    | 53.939     | 53.939     | 53.939     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021452   | 0.021452   | 0.021452   |   0.0 |  0.04
Output  | 6.4711e-05 | 6.4711e-05 | 6.4711e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.22
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 224228
Ave neighs/atom = 56.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905353927101, Press = -0.437389068009019
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13093.904     -13093.904     -13260.738     -13260.738      322.75044      322.75044      67520.278      67520.278     -290.86337     -290.86337    
     61000  -13088.538     -13088.538     -13261.456     -13261.456      334.52335      334.52335      67324.627      67324.627      1728.6502      1728.6502    
Loop time of 54.3188 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.089 hours/ns, 18.410 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    | 54.165     | 54.165     | 54.165     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02114    | 0.02114    | 0.02114    |   0.0 |  0.04
Output  | 5.7448e-05 | 5.7448e-05 | 5.7448e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.22
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 224472
Ave neighs/atom = 56.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.887892132313, Press = 0.599876049790657
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13088.538     -13088.538     -13261.456     -13261.456      334.52335      334.52335      67324.627      67324.627      1728.6502      1728.6502    
     62000  -13096.291     -13096.291     -13266.28      -13266.28       328.85566      328.85566      67567.995      67567.995     -1167.4982     -1167.4982    
Loop time of 54.3485 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.097 hours/ns, 18.400 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    | 54.195     | 54.195     | 54.195     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021399   | 0.021399   | 0.021399   |   0.0 |  0.04
Output  | 8.0561e-05 | 8.0561e-05 | 8.0561e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.22
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 224948
Ave neighs/atom = 56.237
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.860698953799, Press = -0.00157321296972436
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13096.291     -13096.291     -13266.28      -13266.28       328.85566      328.85566      67567.995      67567.995     -1167.4982     -1167.4982    
     63000  -13089.014     -13089.014     -13263.031     -13263.031      336.64686      336.64686      67423.896      67423.896      582.82694      582.82694    
Loop time of 54.2676 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.074 hours/ns, 18.427 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    | 54.114     | 54.114     | 54.114     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021259   | 0.021259   | 0.021259   |   0.0 |  0.04
Output  | 3.4344e-05 | 3.4344e-05 | 3.4344e-05 |   0.0 |  0.00
Modify  | 0.1216     | 0.1216     | 0.1216     |   0.0 |  0.22
Other   |            | 0.01044    |            |       |  0.02

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

Total # of neighbors = 223858
Ave neighs/atom = 55.9645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.842326420446, Press = 0.0754630669198639
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13089.014     -13089.014     -13263.031     -13263.031      336.64686      336.64686      67423.896      67423.896      582.82694      582.82694    
     64000  -13093.115     -13093.115     -13264.284     -13264.284      331.13768      331.13768      67546.302      67546.302     -788.91062     -788.91062    
Loop time of 54.3442 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.590 ns/day, 15.096 hours/ns, 18.401 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    | 54.191     | 54.191     | 54.191     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021403   | 0.021403   | 0.021403   |   0.0 |  0.04
Output  | 6.0112e-05 | 6.0112e-05 | 6.0112e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.22
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 224740
Ave neighs/atom = 56.185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.822563327567, Press = 0.239726666147947
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13093.115     -13093.115     -13264.284     -13264.284      331.13768      331.13768      67546.302      67546.302     -788.91062     -788.91062    
     65000  -13086.627     -13086.627     -13265.21      -13265.21       345.48076      345.48076      67459.505      67459.505      202.07448      202.07448    
Loop time of 54.2392 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.593 ns/day, 15.066 hours/ns, 18.437 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    | 54.086     | 54.086     | 54.086     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 6.2176e-05 | 6.2176e-05 | 6.2176e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.22
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 224202
Ave neighs/atom = 56.0505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.834324268351, Press = -0.319785114861383
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13086.627     -13086.627     -13265.21      -13265.21       345.48076      345.48076      67459.505      67459.505      202.07448      202.07448    
     66000  -13091.969     -13091.969     -13261.253     -13261.253      327.49273      327.49273      67480.531      67480.531      85.101349      85.101349    
Loop time of 54.1558 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.043 hours/ns, 18.465 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    | 54.002     | 54.002     | 54.002     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021389   | 0.021389   | 0.021389   |   0.0 |  0.04
Output  | 5.9742e-05 | 5.9742e-05 | 5.9742e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.22
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 224340
Ave neighs/atom = 56.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.85719700127, Press = 1.26556874884808
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13091.969     -13091.969     -13261.253     -13261.253      327.49273      327.49273      67480.531      67480.531      85.101349      85.101349    
     67000  -13086.803     -13086.803     -13258.392     -13258.392      331.95136      331.95136      67576.594      67576.594     -717.12057     -717.12057    
Loop time of 54.1685 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.595 ns/day, 15.047 hours/ns, 18.461 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    | 54.015     | 54.015     | 54.015     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02152    | 0.02152    | 0.02152    |   0.0 |  0.04
Output  | 5.6315e-05 | 5.6315e-05 | 5.6315e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.22
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 224436
Ave neighs/atom = 56.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879751354679, Press = -0.532459453906886
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13086.803     -13086.803     -13258.392     -13258.392      331.95136      331.95136      67576.594      67576.594     -717.12057     -717.12057    
     68000  -13089.068     -13089.068     -13263.743     -13263.743      337.91961      337.91961      67423.912      67423.912      680.57948      680.57948    
Loop time of 54.2558 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.592 ns/day, 15.071 hours/ns, 18.431 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    | 54.102     | 54.102     | 54.102     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021512   | 0.021512   | 0.021512   |   0.0 |  0.04
Output  | 5.9321e-05 | 5.9321e-05 | 5.9321e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.22
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 224210
Ave neighs/atom = 56.0525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.911109230014, Press = 0.1574399522552
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13089.068     -13089.068     -13263.743     -13263.743      337.91961      337.91961      67423.912      67423.912      680.57948      680.57948    
     69000  -13086.534     -13086.534     -13261.12      -13261.12       337.74835      337.74835      67559.095      67559.095     -725.56275     -725.56275    
Loop time of 54.3206 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.089 hours/ns, 18.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    | 54.167     | 54.167     | 54.167     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02118    | 0.02118    | 0.02118    |   0.0 |  0.04
Output  | 5.9231e-05 | 5.9231e-05 | 5.9231e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  0.22
Other   |            | 0.01044    |            |       |  0.02

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

Total # of neighbors = 224672
Ave neighs/atom = 56.168
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.925491950176, Press = 0.14295148613008
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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13086.534     -13086.534     -13261.12      -13261.12       337.74835      337.74835      67559.095      67559.095     -725.56275     -725.56275    
     70000  -13091.559     -13091.559     -13261.313     -13261.313      328.40075      328.40075      67417.624      67417.624      783.51378      783.51378    
Loop time of 54.3018 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.591 ns/day, 15.084 hours/ns, 18.416 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    | 54.148     | 54.148     | 54.148     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021365   | 0.021365   | 0.021365   |   0.0 |  0.04
Output  | 6.0313e-05 | 6.0313e-05 | 6.0313e-05 |   0.0 |  0.00
Modify  | 0.12165    | 0.12165    | 0.12165    |   0.0 |  0.22
Other   |            | 0.01044    |            |       |  0.02

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

Total # of neighbors = 223988
Ave neighs/atom = 55.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
67485.3870378072

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0