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

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

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

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Ni__MO_444394830472_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17638.129     -17638.129     -17800         -17800          313.15         313.15         43614.208      43614.208      3964.2185      3964.2185    
      1000  -17467.709     -17467.709     -17629.921     -17629.921      313.80951      313.80951      43961.047      43961.047      1436.9736      1436.9736    
Loop time of 32.9718 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.620 ns/day, 9.159 hours/ns, 30.329 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.821     | 32.821     | 32.821     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.07
Output  | 0.00016244 | 0.00016244 | 0.00016244 |   0.0 |  0.00
Modify  | 0.11814    | 0.11814    | 0.11814    |   0.0 |  0.36
Other   |            | 0.01071    |            |       |  0.03

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

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

Performance: 2.353 ns/day, 10.201 hours/ns, 27.230 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    | 36.575     | 36.575     | 36.575     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021383   | 0.021383   | 0.021383   |   0.0 |  0.06
Output  | 5.5214e-05 | 5.5214e-05 | 5.5214e-05 |   0.0 |  0.00
Modify  | 0.11753    | 0.11753    | 0.11753    |   0.0 |  0.32
Other   |            | 0.01044    |            |       |  0.03

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

Total # of neighbors = 314972
Ave neighs/atom = 78.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17470.471     -17470.471     -17630.489     -17630.489      309.56513      309.56513      44004.885      44004.885     -623.22569     -623.22569    
      3000  -17477.346     -17477.346     -17640.329     -17640.329      315.3033       315.3033       44014.537      44014.537     -1130.5514     -1130.5514    
Loop time of 36.9159 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.340 ns/day, 10.254 hours/ns, 27.089 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    | 36.766     | 36.766     | 36.766     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021381   | 0.021381   | 0.021381   |   0.0 |  0.06
Output  | 5.2258e-05 | 5.2258e-05 | 5.2258e-05 |   0.0 |  0.00
Modify  | 0.11751    | 0.11751    | 0.11751    |   0.0 |  0.32
Other   |            | 0.01045    |            |       |  0.03

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

Total # of neighbors = 314904
Ave neighs/atom = 78.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17477.346     -17477.346     -17640.329     -17640.329      315.3033       315.3033       44014.537      44014.537     -1130.5514     -1130.5514    
      4000  -17468.987     -17468.987     -17634.025     -17634.025      319.27647      319.27647      44012.452      44012.452     -967.17674     -967.17674    
Loop time of 36.9273 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.340 ns/day, 10.258 hours/ns, 27.080 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    | 36.778     | 36.778     | 36.778     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021425   | 0.021425   | 0.021425   |   0.0 |  0.06
Output  | 5.3801e-05 | 5.3801e-05 | 5.3801e-05 |   0.0 |  0.00
Modify  | 0.11716    | 0.11716    | 0.11716    |   0.0 |  0.32
Other   |            | 0.01038    |            |       |  0.03

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

Total # of neighbors = 314596
Ave neighs/atom = 78.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17468.987     -17468.987     -17634.025     -17634.025      319.27647      319.27647      44012.452      44012.452     -967.17674     -967.17674    
      5000  -17474.562     -17474.562     -17637.887     -17637.887      315.96321      315.96321      43952.995      43952.995      1169.1459      1169.1459    
Loop time of 36.9566 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.338 ns/day, 10.266 hours/ns, 27.059 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    | 36.807     | 36.807     | 36.807     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021467   | 0.021467   | 0.021467   |   0.0 |  0.06
Output  | 4.6538e-05 | 4.6538e-05 | 4.6538e-05 |   0.0 |  0.00
Modify  | 0.11787    | 0.11787    | 0.11787    |   0.0 |  0.32
Other   |            | 0.01043    |            |       |  0.03

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

Total # of neighbors = 314898
Ave neighs/atom = 78.7245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 309.846591308335, Press = 760.422062967422
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17474.562     -17474.562     -17637.887     -17637.887      315.96321      315.96321      43952.995      43952.995      1169.1459      1169.1459    
      6000  -17474.861     -17474.861     -17635.439     -17635.439      310.64916      310.64916      43954.363      43954.363      1401.0203      1401.0203    
Loop time of 36.9379 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.339 ns/day, 10.261 hours/ns, 27.072 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    | 36.785     | 36.785     | 36.785     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021322   | 0.021322   | 0.021322   |   0.0 |  0.06
Output  | 4.0255e-05 | 4.0255e-05 | 4.0255e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.33
Other   |            | 0.01044    |            |       |  0.03

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

Total # of neighbors = 315112
Ave neighs/atom = 78.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.33828585772, Press = 24.7614756654046
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17474.861     -17474.861     -17635.439     -17635.439      310.64916      310.64916      43954.363      43954.363      1401.0203      1401.0203    
      7000  -17469.375     -17469.375     -17634.158     -17634.158      318.78377      318.78377      43977.788      43977.788      530.84445      530.84445    
Loop time of 36.959 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.338 ns/day, 10.266 hours/ns, 27.057 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    | 36.806     | 36.806     | 36.806     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021405   | 0.021405   | 0.021405   |   0.0 |  0.06
Output  | 2.9535e-05 | 2.9535e-05 | 2.9535e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 315088
Ave neighs/atom = 78.772
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.158838072376, Press = -3.15480550235409
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17469.375     -17469.375     -17634.158     -17634.158      318.78377      318.78377      43977.788      43977.788      530.84445      530.84445    
      8000  -17473.342     -17473.342     -17636.398     -17636.398      315.4417       315.4417       44032.895      44032.895     -1735.8785     -1735.8785    
Loop time of 36.9692 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.269 hours/ns, 27.050 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    | 36.816     | 36.816     | 36.816     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02133    | 0.02133    | 0.02133    |   0.0 |  0.06
Output  | 4.0185e-05 | 4.0185e-05 | 4.0185e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314976
Ave neighs/atom = 78.744
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.010582757395, Press = -6.82558454239402
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17473.342     -17473.342     -17636.398     -17636.398      315.4417       315.4417       44032.895      44032.895     -1735.8785     -1735.8785    
      9000  -17472.198     -17472.198     -17630.487     -17630.487      306.22038      306.22038      44066.486      44066.486     -2701.0762     -2701.0762    
Loop time of 36.9777 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.272 hours/ns, 27.043 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    | 36.825     | 36.825     | 36.825     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021441   | 0.021441   | 0.021441   |   0.0 |  0.06
Output  | 3.711e-05  | 3.711e-05  | 3.711e-05  |   0.0 |  0.00
Modify  | 0.12106    | 0.12106    | 0.12106    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314680
Ave neighs/atom = 78.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.248548545891, Press = 12.6645308634933
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17472.198     -17472.198     -17630.487     -17630.487      306.22038      306.22038      44066.486      44066.486     -2701.0762     -2701.0762    
     10000  -17472.342     -17472.342     -17633.714     -17633.714      312.18354      312.18354      43988.001      43988.001      12.929898      12.929898    
Loop time of 36.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.338 ns/day, 10.266 hours/ns, 27.059 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    | 36.803     | 36.803     | 36.803     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021395   | 0.021395   | 0.021395   |   0.0 |  0.06
Output  | 2.9716e-05 | 2.9716e-05 | 2.9716e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.33
Other   |            | 0.01045    |            |       |  0.03

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

Total # of neighbors = 314710
Ave neighs/atom = 78.6775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.221876565175, Press = 15.6062654176096
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17472.342     -17472.342     -17633.714     -17633.714      312.18354      312.18354      43988.001      43988.001      12.929898      12.929898    
     11000  -17468.582     -17468.582     -17633.811     -17633.811      319.64577      319.64577      43978.123      43978.123      587.6603       587.6603     
Loop time of 37.0376 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.000 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    | 36.884     | 36.884     | 36.884     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021476   | 0.021476   | 0.021476   |   0.0 |  0.06
Output  | 3.9695e-05 | 3.9695e-05 | 3.9695e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314882
Ave neighs/atom = 78.7205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.125462923475, Press = 7.62902609351765
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17468.582     -17468.582     -17633.811     -17633.811      319.64577      319.64577      43978.123      43978.123      587.6603       587.6603     
     12000  -17475.374     -17475.374     -17634.883     -17634.883      308.5804       308.5804       43965.66       43965.66       814.79968      814.79968    
Loop time of 37.0597 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.294 hours/ns, 26.983 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    | 36.906     | 36.906     | 36.906     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021402   | 0.021402   | 0.021402   |   0.0 |  0.06
Output  | 2.9595e-05 | 2.9595e-05 | 2.9595e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 315028
Ave neighs/atom = 78.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.321117548757, Press = 4.5639286709648
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17475.374     -17475.374     -17634.883     -17634.883      308.5804       308.5804       43965.66       43965.66       814.79968      814.79968    
     13000  -17469.742     -17469.742     -17635.665     -17635.665      320.98858      320.98858      43982.441      43982.441      260.5989       260.5989     
Loop time of 37.0272 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.285 hours/ns, 27.007 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    | 36.874     | 36.874     | 36.874     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021656   | 0.021656   | 0.021656   |   0.0 |  0.06
Output  | 4.0135e-05 | 4.0135e-05 | 4.0135e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314886
Ave neighs/atom = 78.7215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.388596157103, Press = -1.68210405566323
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17469.742     -17469.742     -17635.665     -17635.665      320.98858      320.98858      43982.441      43982.441      260.5989       260.5989     
     14000  -17474.971     -17474.971     -17634.192     -17634.192      308.02358      308.02358      44033.505      44033.505     -1845.8588     -1845.8588    
Loop time of 36.9803 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.336 ns/day, 10.272 hours/ns, 27.041 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    | 36.827     | 36.827     | 36.827     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021538   | 0.021538   | 0.021538   |   0.0 |  0.06
Output  | 6.42e-05   | 6.42e-05   | 6.42e-05   |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314966
Ave neighs/atom = 78.7415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.376315933748, Press = -3.93746437809087
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17474.971     -17474.971     -17634.192     -17634.192      308.02358      308.02358      44033.505      44033.505     -1845.8588     -1845.8588    
     15000  -17474.058     -17474.058     -17633.803     -17633.803      309.03749      309.03749      44058.743      44058.743     -2716.4048     -2716.4048    
Loop time of 37.0536 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.988 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    | 36.901     | 36.901     | 36.901     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021403   | 0.021403   | 0.021403   |   0.0 |  0.06
Output  | 2.9715e-05 | 2.9715e-05 | 2.9715e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.33
Other   |            | 0.01054    |            |       |  0.03

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

Total # of neighbors = 314776
Ave neighs/atom = 78.694
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.604976558521, Press = 3.92756851942618
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17474.058     -17474.058     -17633.803     -17633.803      309.03749      309.03749      44058.743      44058.743     -2716.4048     -2716.4048    
     16000  -17471.415     -17471.415     -17632.614     -17632.614      311.85011      311.85011      43996.939      43996.939     -169.17708     -169.17708    
Loop time of 36.9232 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.340 ns/day, 10.256 hours/ns, 27.083 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    | 36.77      | 36.77      | 36.77      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021375   | 0.021375   | 0.021375   |   0.0 |  0.06
Output  | 3.9394e-05 | 3.9394e-05 | 3.9394e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314654
Ave neighs/atom = 78.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.591261404987, Press = 4.30772173600496
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17471.415     -17471.415     -17632.614     -17632.614      311.85011      311.85011      43996.939      43996.939     -169.17708     -169.17708    
     17000  -17472.88      -17472.88      -17634.673     -17634.673      312.99853      312.99853      43983.082      43983.082      127.48063      127.48063    
Loop time of 37.0544 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.987 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    | 36.901     | 36.901     | 36.901     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021452   | 0.021452   | 0.021452   |   0.0 |  0.06
Output  | 2.9586e-05 | 2.9586e-05 | 2.9586e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314922
Ave neighs/atom = 78.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.652455043965, Press = 2.71032816624562
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17472.88      -17472.88      -17634.673     -17634.673      312.99853      312.99853      43983.082      43983.082      127.48063      127.48063    
     18000  -17476.503     -17476.503     -17636.974     -17636.974      310.44234      310.44234      43978.006      43978.006      310.14548      310.14548    
Loop time of 36.9655 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.268 hours/ns, 27.052 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    | 36.813     | 36.813     | 36.813     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021432   | 0.021432   | 0.021432   |   0.0 |  0.06
Output  | 3.8893e-05 | 3.8893e-05 | 3.8893e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314974
Ave neighs/atom = 78.7435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.628727920517, Press = 1.50778167278311
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17476.503     -17476.503     -17636.974     -17636.974      310.44234      310.44234      43978.006      43978.006      310.14548      310.14548    
     19000  -17473.084     -17473.084     -17635.859     -17635.859      314.89876      314.89876      43988.065      43988.065     -24.089937     -24.089937    
Loop time of 36.9716 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.270 hours/ns, 27.048 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    | 36.819     | 36.819     | 36.819     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02141    | 0.02141    | 0.02141    |   0.0 |  0.06
Output  | 3.9033e-05 | 3.9033e-05 | 3.9033e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314832
Ave neighs/atom = 78.708
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.54336961442, Press = -0.186798137867526
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17473.084     -17473.084     -17635.859     -17635.859      314.89876      314.89876      43988.065      43988.065     -24.089937     -24.089937    
     20000  -17468.226     -17468.226     -17634.414     -17634.414      321.50101      321.50101      44025.941      44025.941     -1367.7083     -1367.7083    
Loop time of 36.9694 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.269 hours/ns, 27.049 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    | 36.816     | 36.816     | 36.816     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021423   | 0.021423   | 0.021423   |   0.0 |  0.06
Output  | 3.0087e-05 | 3.0087e-05 | 3.0087e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.33
Other   |            | 0.01046    |            |       |  0.03

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

Total # of neighbors = 314840
Ave neighs/atom = 78.71
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.479574353453, Press = 1.10600748022904
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17468.226     -17468.226     -17634.414     -17634.414      321.50101      321.50101      44025.941      44025.941     -1367.7083     -1367.7083    
     21000  -17473.012     -17473.012     -17635.98      -17635.98       315.27256      315.27256      44015.488      44015.488     -1081.154      -1081.154     
Loop time of 36.9696 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.269 hours/ns, 27.049 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    | 36.816     | 36.816     | 36.816     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021438   | 0.021438   | 0.021438   |   0.0 |  0.06
Output  | 4.0226e-05 | 4.0226e-05 | 4.0226e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314688
Ave neighs/atom = 78.672
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.500927998902, Press = 4.44311264176764
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17473.012     -17473.012     -17635.98      -17635.98       315.27256      315.27256      44015.488      44015.488     -1081.154      -1081.154     
     22000  -17473.813     -17473.813     -17637.05      -17637.05       315.79201      315.79201      43948.976      43948.976      1535.4593      1535.4593    
Loop time of 36.9911 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.336 ns/day, 10.275 hours/ns, 27.034 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    | 36.838     | 36.838     | 36.838     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021476   | 0.021476   | 0.021476   |   0.0 |  0.06
Output  | 4.3893e-05 | 4.3893e-05 | 4.3893e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314820
Ave neighs/atom = 78.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.545037521629, Press = 4.5141905597678
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17473.813     -17473.813     -17637.05      -17637.05       315.79201      315.79201      43948.976      43948.976      1535.4593      1535.4593    
     23000  -17470.344     -17470.344     -17633.245     -17633.245      315.14348      315.14348      43963.593      43963.593      1184.2079      1184.2079    
Loop time of 37.0591 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.294 hours/ns, 26.984 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    | 36.906     | 36.906     | 36.906     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021396   | 0.021396   | 0.021396   |   0.0 |  0.06
Output  | 2.9435e-05 | 2.9435e-05 | 2.9435e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314942
Ave neighs/atom = 78.7355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.606047532609, Press = 1.10698226474013
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17470.344     -17470.344     -17633.245     -17633.245      315.14348      315.14348      43963.593      43963.593      1184.2079      1184.2079    
     24000  -17469.02      -17469.02      -17633.742     -17633.742      318.66595      318.66595      43995.607      43995.607     -242.76075     -242.76075    
Loop time of 37.0354 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 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    | 36.882     | 36.882     | 36.882     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021551   | 0.021551   | 0.021551   |   0.0 |  0.06
Output  | 3.9134e-05 | 3.9134e-05 | 3.9134e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314900
Ave neighs/atom = 78.725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.58710098958, Press = 0.488702289546751
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17469.02      -17469.02      -17633.742     -17633.742      318.66595      318.66595      43995.607      43995.607     -242.76075     -242.76075    
     25000  -17475.819     -17475.819     -17635.819     -17635.819      309.53056      309.53056      43999.408      43999.408     -688.48265     -688.48265    
Loop time of 37.0545 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.987 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    | 36.902     | 36.902     | 36.902     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021386   | 0.021386   | 0.021386   |   0.0 |  0.06
Output  | 2.9466e-05 | 2.9466e-05 | 2.9466e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.33
Other   |            | 0.01046    |            |       |  0.03

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

Total # of neighbors = 314968
Ave neighs/atom = 78.742
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.683790921593, Press = 0.761205193899889
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17475.819     -17475.819     -17635.819     -17635.819      309.53056      309.53056      43999.408      43999.408     -688.48265     -688.48265    
     26000  -17475.33      -17475.33      -17635.863     -17635.863      310.56251      310.56251      44006.696      44006.696     -800.16573     -800.16573    
Loop time of 37.0502 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.292 hours/ns, 26.990 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    | 36.897     | 36.897     | 36.897     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02152    | 0.02152    | 0.02152    |   0.0 |  0.06
Output  | 4.9393e-05 | 4.9393e-05 | 4.9393e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314926
Ave neighs/atom = 78.7315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.67749798265, Press = 1.37111969381607
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17475.33      -17475.33      -17635.863     -17635.863      310.56251      310.56251      44006.696      44006.696     -800.16573     -800.16573    
     27000  -17472.971     -17472.971     -17635.723     -17635.723      314.85494      314.85494      44001.119      44001.119     -643.45023     -643.45023    
Loop time of 36.9653 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.337 ns/day, 10.268 hours/ns, 27.052 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    | 36.812     | 36.812     | 36.812     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02142    | 0.02142    | 0.02142    |   0.0 |  0.06
Output  | 3.8292e-05 | 3.8292e-05 | 3.8292e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.33
Other   |            | 0.01047    |            |       |  0.03

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

Total # of neighbors = 314728
Ave neighs/atom = 78.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.677808669572, Press = 2.18823788258411
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17472.971     -17472.971     -17635.723     -17635.723      314.85494      314.85494      44001.119      44001.119     -643.45023     -643.45023    
     28000  -17470.031     -17470.031     -17631.996     -17631.996      313.3329       313.3329       43975.588      43975.588      488.22155      488.22155    
Loop time of 37.0361 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 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    | 36.883     | 36.883     | 36.883     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02146    | 0.02146    | 0.02146    |   0.0 |  0.06
Output  | 2.9375e-05 | 2.9375e-05 | 2.9375e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314912
Ave neighs/atom = 78.728
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.700893887388, Press = 2.17654493330491
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17470.031     -17470.031     -17631.996     -17631.996      313.3329       313.3329       43975.588      43975.588      488.22155      488.22155    
     29000  -17474.228     -17474.228     -17638.695     -17638.695      318.17272      318.17272      43949.667      43949.667      1358.8611      1358.8611    
Loop time of 37.0592 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.294 hours/ns, 26.984 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    | 36.906     | 36.906     | 36.906     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021436   | 0.021436   | 0.021436   |   0.0 |  0.06
Output  | 3.9164e-05 | 3.9164e-05 | 3.9164e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314972
Ave neighs/atom = 78.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.714242053139, Press = 1.53358391965815
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17474.228     -17474.228     -17638.695     -17638.695      318.17272      318.17272      43949.667      43949.667      1358.8611      1358.8611    
     30000  -17470.426     -17470.426     -17633.455     -17633.455      315.38945      315.38945      43959.457      43959.457      1302.8811      1302.8811    
Loop time of 37.0027 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.279 hours/ns, 27.025 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    | 36.85      | 36.85      | 36.85      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02155    | 0.02155    | 0.02155    |   0.0 |  0.06
Output  | 2.9495e-05 | 2.9495e-05 | 2.9495e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314818
Ave neighs/atom = 78.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.694821739282, Press = -0.961249808731222
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17470.426     -17470.426     -17633.455     -17633.455      315.38945      315.38945      43959.457      43959.457      1302.8811      1302.8811    
     31000  -17474.336     -17474.336     -17633.606     -17633.606      308.11789      308.11789      44010.006      44010.006     -1048.742      -1048.742     
Loop time of 36.9969 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.277 hours/ns, 27.029 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    | 36.844     | 36.844     | 36.844     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.06
Output  | 4.3792e-05 | 4.3792e-05 | 4.3792e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314910
Ave neighs/atom = 78.7275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.596084723435, Press = -2.03126684470181
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17474.336     -17474.336     -17633.606     -17633.606      308.11789      308.11789      44010.006      44010.006     -1048.742      -1048.742     
     32000  -17471.293     -17471.293     -17635.604     -17635.604      317.87057      317.87057      44027.592      44027.592     -1638.5259     -1638.5259    
Loop time of 37.035 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 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    | 36.882     | 36.882     | 36.882     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021545   | 0.021545   | 0.021545   |   0.0 |  0.06
Output  | 3.9133e-05 | 3.9133e-05 | 3.9133e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314860
Ave neighs/atom = 78.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.62235833983, Press = 0.617481995888353
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17471.293     -17471.293     -17635.604     -17635.604      317.87057      317.87057      44027.592      44027.592     -1638.5259     -1638.5259    
     33000  -17473.77      -17473.77      -17635.208     -17635.208      312.31242      312.31242      43991.546      43991.546     -226.90482     -226.90482    
Loop time of 36.9965 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.277 hours/ns, 27.030 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    | 36.844     | 36.844     | 36.844     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021329   | 0.021329   | 0.021329   |   0.0 |  0.06
Output  | 2.9516e-05 | 2.9516e-05 | 2.9516e-05 |   0.0 |  0.00
Modify  | 0.12106    | 0.12106    | 0.12106    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314762
Ave neighs/atom = 78.6905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.59451321629, Press = 1.37362741518677
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17473.77      -17473.77      -17635.208     -17635.208      312.31242      312.31242      43991.546      43991.546     -226.90482     -226.90482    
     34000  -17472.028     -17472.028     -17634.144     -17634.144      313.62351      313.62351      43977.318      43977.318      515.53648      515.53648    
Loop time of 37.0349 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.287 hours/ns, 27.002 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    | 36.882     | 36.882     | 36.882     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02162    | 0.02162    | 0.02162    |   0.0 |  0.06
Output  | 4.2079e-05 | 4.2079e-05 | 4.2079e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314904
Ave neighs/atom = 78.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.585515479424, Press = 1.72083809744188
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17472.028     -17472.028     -17634.144     -17634.144      313.62351      313.62351      43977.318      43977.318      515.53648      515.53648    
     35000  -17475.242     -17475.242     -17634.64      -17634.64       308.36657      308.36657      43936.832      43936.832      2047.4644      2047.4644    
Loop time of 37.0019 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.278 hours/ns, 27.026 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    | 36.849     | 36.849     | 36.849     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021451   | 0.021451   | 0.021451   |   0.0 |  0.06
Output  | 3.7761e-05 | 3.7761e-05 | 3.7761e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314988
Ave neighs/atom = 78.747
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.56626157454, Press = 0.792758180176293
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17475.242     -17475.242     -17634.64      -17634.64       308.36657      308.36657      43936.832      43936.832      2047.4644      2047.4644    
     36000  -17471.092     -17471.092     -17635.285     -17635.285      317.64236      317.64236      43962.589      43962.589      1060.3239      1060.3239    
Loop time of 37.0434 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.290 hours/ns, 26.995 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    | 36.89      | 36.89      | 36.89      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021477   | 0.021477   | 0.021477   |   0.0 |  0.06
Output  | 2.9485e-05 | 2.9485e-05 | 2.9485e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314908
Ave neighs/atom = 78.727
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.62759622666, Press = -1.51250658754547
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17471.092     -17471.092     -17635.285     -17635.285      317.64236      317.64236      43962.589      43962.589      1060.3239      1060.3239    
     37000  -17469.051     -17469.051     -17633.94      -17633.94       318.98949      318.98949      44036.798      44036.798     -1908.4212     -1908.4212    
Loop time of 37.0356 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.288 hours/ns, 27.001 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    | 36.882     | 36.882     | 36.882     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021379   | 0.021379   | 0.021379   |   0.0 |  0.06
Output  | 3.9184e-05 | 3.9184e-05 | 3.9184e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.33
Other   |            | 0.01054    |            |       |  0.03

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

Total # of neighbors = 314846
Ave neighs/atom = 78.7115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.63256837504, Press = -1.14253491068883
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17469.051     -17469.051     -17633.94      -17633.94       318.98949      318.98949      44036.798      44036.798     -1908.4212     -1908.4212    
     38000  -17473.203     -17473.203     -17634.608     -17634.608      312.24743      312.24743      44031.874      44031.874     -1775.233      -1775.233     
Loop time of 37.0533 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.988 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    | 36.9       | 36.9       | 36.9       |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021466   | 0.021466   | 0.021466   |   0.0 |  0.06
Output  | 2.9665e-05 | 2.9665e-05 | 2.9665e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314752
Ave neighs/atom = 78.688
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.640502284604, Press = 0.846531155378672
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17473.203     -17473.203     -17634.608     -17634.608      312.24743      312.24743      44031.874      44031.874     -1775.233      -1775.233     
     39000  -17469.744     -17469.744     -17633.806     -17633.806      317.3892       317.3892       44000.144      44000.144     -422.50933     -422.50933    
Loop time of 37.0441 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.290 hours/ns, 26.995 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    | 36.891     | 36.891     | 36.891     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021437   | 0.021437   | 0.021437   |   0.0 |  0.06
Output  | 4.0206e-05 | 4.0206e-05 | 4.0206e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314832
Ave neighs/atom = 78.708
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.616294689877, Press = 1.49790116090291
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17469.744     -17469.744     -17633.806     -17633.806      317.3892       317.3892       44000.144      44000.144     -422.50933     -422.50933    
     40000  -17477.699     -17477.699     -17637.611     -17637.611      309.36134      309.36134      43965.432      43965.432      667.75222      667.75222    
Loop time of 37.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.279 hours/ns, 27.023 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    | 36.853     | 36.853     | 36.853     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021412   | 0.021412   | 0.021412   |   0.0 |  0.06
Output  | 3.8081e-05 | 3.8081e-05 | 3.8081e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314832
Ave neighs/atom = 78.708
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.562805330768, Press = 1.45313112710477
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17477.699     -17477.699     -17637.611     -17637.611      309.36134      309.36134      43965.432      43965.432      667.75222      667.75222    
     41000  -17473.435     -17473.435     -17636.662     -17636.662      315.77317      315.77317      43963.458      43963.458      1075.931       1075.931     
Loop time of 37.0265 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.285 hours/ns, 27.008 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    | 36.874     | 36.874     | 36.874     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021373   | 0.021373   | 0.021373   |   0.0 |  0.06
Output  | 2.9655e-05 | 2.9655e-05 | 2.9655e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 314904
Ave neighs/atom = 78.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.564019891486, Press = 0.562358392891511
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17473.435     -17473.435     -17636.662     -17636.662      315.77317      315.77317      43963.458      43963.458      1075.931       1075.931     
     42000  -17472.182     -17472.182     -17637.181     -17637.181      319.20158      319.20158      43983.466      43983.466      158.40849      158.40849    
Loop time of 36.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.336 ns/day, 10.273 hours/ns, 27.039 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    | 36.831     | 36.831     | 36.831     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021392   | 0.021392   | 0.021392   |   0.0 |  0.06
Output  | 3.9124e-05 | 3.9124e-05 | 3.9124e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.33
Other   |            | 0.01047    |            |       |  0.03

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

Total # of neighbors = 314902
Ave neighs/atom = 78.7255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.516875464147, Press = -0.767640949915114
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17472.182     -17472.182     -17637.181     -17637.181      319.20158      319.20158      43983.466      43983.466      158.40849      158.40849    
     43000  -17474.433     -17474.433     -17637.063     -17637.063      314.61934      314.61934      44050.478      44050.478     -2566.363      -2566.363     
Loop time of 36.9791 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.336 ns/day, 10.272 hours/ns, 27.042 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    | 36.826     | 36.826     | 36.826     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021405   | 0.021405   | 0.021405   |   0.0 |  0.06
Output  | 2.9846e-05 | 2.9846e-05 | 2.9846e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314798
Ave neighs/atom = 78.6995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446034187211, Press = -0.266742474771071
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17474.433     -17474.433     -17637.063     -17637.063      314.61934      314.61934      44050.478      44050.478     -2566.363      -2566.363     
     44000  -17475.669     -17475.669     -17634.98      -17634.98       308.19851      308.19851      44036.601      44036.601     -1892.3887     -1892.3887    
Loop time of 37.0144 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.334 ns/day, 10.282 hours/ns, 27.017 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    | 36.861     | 36.861     | 36.861     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021434   | 0.021434   | 0.021434   |   0.0 |  0.06
Output  | 4.1418e-05 | 4.1418e-05 | 4.1418e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314618
Ave neighs/atom = 78.6545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426602199347, Press = 1.45075859843567
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17475.669     -17475.669     -17634.98      -17634.98       308.19851      308.19851      44036.601      44036.601     -1892.3887     -1892.3887    
     45000  -17471.983     -17471.983     -17634.578     -17634.578      314.55207      314.55207      43985.433      43985.433      127.99507      127.99507    
Loop time of 37.1237 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.327 ns/day, 10.312 hours/ns, 26.937 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    | 36.971     | 36.971     | 36.971     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021335   | 0.021335   | 0.021335   |   0.0 |  0.06
Output  | 3.8493e-05 | 3.8493e-05 | 3.8493e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314750
Ave neighs/atom = 78.6875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.482347170615, Press = 1.64993904250549
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17471.983     -17471.983     -17634.578     -17634.578      314.55207      314.55207      43985.433      43985.433      127.99507      127.99507    
     46000  -17470.398     -17470.398     -17632.638     -17632.638      313.86331      313.86331      43968.072      43968.072      958.47504      958.47504    
Loop time of 37.1202 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.328 ns/day, 10.311 hours/ns, 26.940 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    | 36.967     | 36.967     | 36.967     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021468   | 0.021468   | 0.021468   |   0.0 |  0.06
Output  | 2.9044e-05 | 2.9044e-05 | 2.9044e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314906
Ave neighs/atom = 78.7265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.47615521058, Press = 1.07460499147776
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17470.398     -17470.398     -17632.638     -17632.638      313.86331      313.86331      43968.072      43968.072      958.47504      958.47504    
     47000  -17473.478     -17473.478     -17634.89      -17634.89       312.26273      312.26273      43951.013      43951.013      1627.5709      1627.5709    
Loop time of 37.1319 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.327 ns/day, 10.314 hours/ns, 26.931 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    | 36.979     | 36.979     | 36.979     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02137    | 0.02137    | 0.02137    |   0.0 |  0.06
Output  | 4.0185e-05 | 4.0185e-05 | 4.0185e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314946
Ave neighs/atom = 78.7365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.485404409881, Press = 0.499085578794533
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17473.478     -17473.478     -17634.89      -17634.89       312.26273      312.26273      43951.013      43951.013      1627.5709      1627.5709    
     48000  -17470.166     -17470.166     -17635.747     -17635.747      320.32765      320.32765      43963.983      43963.983      1083.864       1083.864     
Loop time of 37.1202 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.328 ns/day, 10.311 hours/ns, 26.940 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    | 36.967     | 36.967     | 36.967     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021429   | 0.021429   | 0.021429   |   0.0 |  0.06
Output  | 3.6329e-05 | 3.6329e-05 | 3.6329e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314934
Ave neighs/atom = 78.7335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.522085214674, Press = -0.210422199113137
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17470.166     -17470.166     -17635.747     -17635.747      320.32765      320.32765      43963.983      43963.983      1083.864       1083.864     
     49000  -17470.221     -17470.221     -17635.597     -17635.597      319.93032      319.93032      43995.983      43995.983     -224.55863     -224.55863    
Loop time of 37.1352 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.327 ns/day, 10.315 hours/ns, 26.929 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    | 36.982     | 36.982     | 36.982     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021437   | 0.021437   | 0.021437   |   0.0 |  0.06
Output  | 2.9435e-05 | 2.9435e-05 | 2.9435e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314826
Ave neighs/atom = 78.7065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.512902617056, Press = -0.102024811128409
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17470.221     -17470.221     -17635.597     -17635.597      319.93032      319.93032      43995.983      43995.983     -224.55863     -224.55863    
     50000  -17473.956     -17473.956     -17634.325     -17634.325      310.24417      310.24417      44021.451      44021.451     -1403.2881     -1403.2881    
Loop time of 37.1372 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.327 ns/day, 10.316 hours/ns, 26.927 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    | 36.984     | 36.984     | 36.984     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021499   | 0.021499   | 0.021499   |   0.0 |  0.06
Output  | 4.0666e-05 | 4.0666e-05 | 4.0666e-05 |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314828
Ave neighs/atom = 78.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.457708147939, Press = 0.0846971466178222
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17473.956     -17473.956     -17634.325     -17634.325      310.24417      310.24417      44021.451      44021.451     -1403.2881     -1403.2881    
     51000  -17476.042     -17476.042     -17636.837     -17636.837      311.06849      311.06849      44024.181      44024.181     -1654.3345     -1654.3345    
Loop time of 37.0457 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.290 hours/ns, 26.994 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    | 36.892     | 36.892     | 36.892     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021513   | 0.021513   | 0.021513   |   0.0 |  0.06
Output  | 4.3642e-05 | 4.3642e-05 | 4.3642e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314742
Ave neighs/atom = 78.6855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.436590874935, Press = 1.41104062930836
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17476.042     -17476.042     -17636.837     -17636.837      311.06849      311.06849      44024.181      44024.181     -1654.3345     -1654.3345    
     52000  -17471.172     -17471.172     -17634.852     -17634.852      316.64997      316.64997      43939.478      43939.478      2042.0331      2042.0331    
Loop time of 37.0561 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.293 hours/ns, 26.986 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    | 36.903     | 36.903     | 36.903     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021487   | 0.021487   | 0.021487   |   0.0 |  0.06
Output  | 3.9845e-05 | 3.9845e-05 | 3.9845e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314680
Ave neighs/atom = 78.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41930550371, Press = 3.06102170953933
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17471.172     -17471.172     -17634.852     -17634.852      316.64997      316.64997      43939.478      43939.478      2042.0331      2042.0331    
     53000  -17473.921     -17473.921     -17636.34      -17636.34       314.21126      314.21126      43948.388      43948.388      1444.2039      1444.2039    
Loop time of 37.0704 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.297 hours/ns, 26.976 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    | 36.917     | 36.917     | 36.917     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021386   | 0.021386   | 0.021386   |   0.0 |  0.06
Output  | 3.9374e-05 | 3.9374e-05 | 3.9374e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.33
Other   |            | 0.01049    |            |       |  0.03

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

Total # of neighbors = 315022
Ave neighs/atom = 78.7555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.365898406078, Press = 0.548430457527044
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17473.921     -17473.921     -17636.34      -17636.34       314.21126      314.21126      43948.388      43948.388      1444.2039      1444.2039    
     54000  -17474.082     -17474.082     -17633.524     -17633.524      308.4511       308.4511       43978.526      43978.526      325.3856       325.3856     
Loop time of 37.0608 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.295 hours/ns, 26.983 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    | 36.908     | 36.908     | 36.908     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021482   | 0.021482   | 0.021482   |   0.0 |  0.06
Output  | 2.9536e-05 | 2.9536e-05 | 2.9536e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.33
Other   |            | 0.01047    |            |       |  0.03

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

Total # of neighbors = 314850
Ave neighs/atom = 78.7125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.36993503679, Press = 0.0659245281714792
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17474.082     -17474.082     -17633.524     -17633.524      308.4511       308.4511       43978.526      43978.526      325.3856       325.3856     
     55000  -17472.46      -17472.46      -17635.807     -17635.807      316.005        316.005        43997.991      43997.991     -330.09045     -330.09045    
Loop time of 37.1054 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.328 ns/day, 10.307 hours/ns, 26.950 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    | 36.952     | 36.952     | 36.952     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021425   | 0.021425   | 0.021425   |   0.0 |  0.06
Output  | 3.9193e-05 | 3.9193e-05 | 3.9193e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 315030
Ave neighs/atom = 78.7575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.351026328784, Press = 0.481227157809107
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17472.46      -17472.46      -17635.807     -17635.807      316.005        316.005        43997.991      43997.991     -330.09045     -330.09045    
     56000  -17477.063     -17477.063     -17637.329     -17637.329      310.04561      310.04561      43997.406      43997.406     -571.32866     -571.32866    
Loop time of 36.9788 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.336 ns/day, 10.272 hours/ns, 27.042 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    | 36.826     | 36.826     | 36.826     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.06
Output  | 2.9455e-05 | 2.9455e-05 | 2.9455e-05 |   0.0 |  0.00
Modify  | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314774
Ave neighs/atom = 78.6935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.299702256961, Press = 0.719828289223191
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17477.063     -17477.063     -17637.329     -17637.329      310.04561      310.04561      43997.406      43997.406     -571.32866     -571.32866    
     57000  -17475.404     -17475.404     -17635.906     -17635.906      310.50191      310.50191      43978.11       43978.11       450.465        450.465      
Loop time of 37.0663 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.296 hours/ns, 26.979 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    | 36.913     | 36.913     | 36.913     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021487   | 0.021487   | 0.021487   |   0.0 |  0.06
Output  | 4.3562e-05 | 4.3562e-05 | 4.3562e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314792
Ave neighs/atom = 78.698
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.28469552098, Press = 1.26021582227652
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17475.404     -17475.404     -17635.906     -17635.906      310.50191      310.50191      43978.11       43978.11       450.465        450.465      
     58000  -17471.739     -17471.739     -17633.532     -17633.532      313.00056      313.00056      43937.606      43937.606      2067.7688      2067.7688    
Loop time of 37.0593 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.294 hours/ns, 26.984 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    | 36.906     | 36.906     | 36.906     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021507   | 0.021507   | 0.021507   |   0.0 |  0.06
Output  | 4.0306e-05 | 4.0306e-05 | 4.0306e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314738
Ave neighs/atom = 78.6845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.246547819442, Press = 0.424441990556882
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17471.739     -17471.739     -17633.532     -17633.532      313.00056      313.00056      43937.606      43937.606      2067.7688      2067.7688    
     59000  -17474.669     -17474.669     -17635.525     -17635.525      311.18677      311.18677      43955.022      43955.022      1175.2373      1175.2373    
Loop time of 37.0638 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.331 ns/day, 10.295 hours/ns, 26.981 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    | 36.911     | 36.911     | 36.911     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021467   | 0.021467   | 0.021467   |   0.0 |  0.06
Output  | 5.5394e-05 | 5.5394e-05 | 5.5394e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.33
Other   |            | 0.01047    |            |       |  0.03

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

Total # of neighbors = 315046
Ave neighs/atom = 78.7615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.236133512656, Press = -0.437935350478207
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17474.669     -17474.669     -17635.525     -17635.525      311.18677      311.18677      43955.022      43955.022      1175.2373      1175.2373    
     60000  -17477.036     -17477.036     -17638.217     -17638.217      311.8141       311.8141       44009.653      44009.653     -1152.8629     -1152.8629    
Loop time of 37.1446 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.326 ns/day, 10.318 hours/ns, 26.922 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    | 36.991     | 36.991     | 36.991     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021458   | 0.021458   | 0.021458   |   0.0 |  0.06
Output  | 4.0076e-05 | 4.0076e-05 | 4.0076e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 315004
Ave neighs/atom = 78.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.214136021856, Press = -0.558441609020813
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17477.036     -17477.036     -17638.217     -17638.217      311.8141       311.8141       44009.653      44009.653     -1152.8629     -1152.8629    
     61000  -17472.391     -17472.391     -17634.242     -17634.242      313.11104      313.11104      44013.492      44013.492     -1001.1123     -1001.1123    
Loop time of 37.0464 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.332 ns/day, 10.291 hours/ns, 26.993 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    | 36.893     | 36.893     | 36.893     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021476   | 0.021476   | 0.021476   |   0.0 |  0.06
Output  | 3.8052e-05 | 3.8052e-05 | 3.8052e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314734
Ave neighs/atom = 78.6835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.189191225989, Press = 0.582042922395783
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17472.391     -17472.391     -17634.242     -17634.242      313.11104      313.11104      44013.492      44013.492     -1001.1123     -1001.1123    
     62000  -17473.371     -17473.371     -17634.603     -17634.603      311.9144       311.9144       43983.633      43983.633      299.24645      299.24645    
Loop time of 37.1353 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.327 ns/day, 10.315 hours/ns, 26.929 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    | 36.982     | 36.982     | 36.982     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021483   | 0.021483   | 0.021483   |   0.0 |  0.06
Output  | 2.9295e-05 | 2.9295e-05 | 2.9295e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

Total # of neighbors = 314828
Ave neighs/atom = 78.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.183700037628, Press = 0.774839913297046
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17473.371     -17473.371     -17634.603     -17634.603      311.9144       311.9144       43983.633      43983.633      299.24645      299.24645    
     63000  -17476.386     -17476.386     -17637.887     -17637.887      312.43521      312.43521      43969.124      43969.124      554.56068      554.56068    
Loop time of 37.1597 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.325 ns/day, 10.322 hours/ns, 26.911 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    | 37.006     | 37.006     | 37.006     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021486   | 0.021486   | 0.021486   |   0.0 |  0.06
Output  | 3.9214e-05 | 3.9214e-05 | 3.9214e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314824
Ave neighs/atom = 78.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.184643349855, Press = 0.405435790558005
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17476.386     -17476.386     -17637.887     -17637.887      312.43521      312.43521      43969.124      43969.124      554.56068      554.56068    
     64000  -17475.061     -17475.061     -17636.317     -17636.317      311.95922      311.95922      43970.662      43970.662      599.53899      599.53899    
Loop time of 36.9989 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.335 ns/day, 10.277 hours/ns, 27.028 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    | 36.846     | 36.846     | 36.846     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021399   | 0.021399   | 0.021399   |   0.0 |  0.06
Output  | 3.2231e-05 | 3.2231e-05 | 3.2231e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.33
Other   |            | 0.0105     |            |       |  0.03

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

Total # of neighbors = 314820
Ave neighs/atom = 78.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.177481007937, Press = -0.274271467906974
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17475.061     -17475.061     -17636.317     -17636.317      311.95922      311.95922      43970.662      43970.662      599.53899      599.53899    
     65000  -17475.458     -17475.458     -17637.169     -17637.169      312.84073      312.84073      44044.957      44044.957     -2389.6833     -2389.6833    
Loop time of 37.1562 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.325 ns/day, 10.321 hours/ns, 26.913 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    | 37.003     | 37.003     | 37.003     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021498   | 0.021498   | 0.021498   |   0.0 |  0.06
Output  | 4.0015e-05 | 4.0015e-05 | 4.0015e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  0.33
Other   |            | 0.01051    |            |       |  0.03

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

Total # of neighbors = 314822
Ave neighs/atom = 78.7055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.190698569971, Press = -0.368151705246817
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17475.458     -17475.458     -17637.169     -17637.169      312.84073      312.84073      44044.957      44044.957     -2389.6833     -2389.6833    
     66000  -17469.616     -17469.616     -17631.326     -17631.326      312.83987      312.83987      44040.241      44040.241     -1796.9959     -1796.9959    
Loop time of 37.0803 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.330 ns/day, 10.300 hours/ns, 26.969 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    | 36.927     | 36.927     | 36.927     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021438   | 0.021438   | 0.021438   |   0.0 |  0.06
Output  | 3.8944e-05 | 3.8944e-05 | 3.8944e-05 |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.33
Other   |            | 0.01053    |            |       |  0.03

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

Total # of neighbors = 314704
Ave neighs/atom = 78.676
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.191911921649, Press = 0.982846307249068
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17469.616     -17469.616     -17631.326     -17631.326      312.83987      312.83987      44040.241      44040.241     -1796.9959     -1796.9959    
     67000  -17473.227     -17473.227     -17632.802     -17632.802      308.70898      308.70898      43979.618      43979.618      363.71913      363.71913    
Loop time of 37.0316 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.333 ns/day, 10.287 hours/ns, 27.004 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    | 36.878     | 36.878     | 36.878     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021488   | 0.021488   | 0.021488   |   0.0 |  0.06
Output  | 2.9766e-05 | 2.9766e-05 | 2.9766e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.33
Other   |            | 0.01046    |            |       |  0.03

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

Total # of neighbors = 314744
Ave neighs/atom = 78.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.183252990765, Press = 0.957569528606348
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17473.227     -17473.227     -17632.802     -17632.802      308.70898      308.70898      43979.618      43979.618      363.71913      363.71913    
     68000  -17476.575     -17476.575     -17636.651     -17636.651      309.67785      309.67785      43961.206      43961.206      941.79056      941.79056    
Loop time of 37.1742 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.324 ns/day, 10.326 hours/ns, 26.900 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    | 37.021     | 37.021     | 37.021     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021488   | 0.021488   | 0.021488   |   0.0 |  0.06
Output  | 3.9885e-05 | 3.9885e-05 | 3.9885e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.33
Other   |            | 0.01052    |            |       |  0.03

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

Total # of neighbors = 314930
Ave neighs/atom = 78.7325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.178831728354, Press = 0.415498817161307
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17476.575     -17476.575     -17636.651     -17636.651      309.67785      309.67785      43961.206      43961.206      941.79056      941.79056    
     69000  -17474.867     -17474.867     -17636.395     -17636.395      312.48747      312.48747      43979.007      43979.007      239.37427      239.37427    
Loop time of 37.1624 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.325 ns/day, 10.323 hours/ns, 26.909 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    | 37.009     | 37.009     | 37.009     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021381   | 0.021381   | 0.021381   |   0.0 |  0.06
Output  | 2.8935e-05 | 2.8935e-05 | 2.8935e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.33
Other   |            | 0.01048    |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0