# 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.889087237417698*${_u_distance}
variable latticeconst_converted equal 3.889087237417698*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.8890872374177
Lattice spacing in x,y,z = 3.8890872 3.8890872 3.8890872
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (38.890872 38.890872 38.890872)
  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 (38.890872 38.890872 38.890872)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoLee_2013_VPdY__MO_046547823135_002
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 58822.4426779163 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_046547823135_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -15478.129     -15478.129     -15640         -15640          313.15         313.15         58822.443      58822.443      2939.3412      2939.3412    
      1000  -15319.199     -15319.199     -15481.387     -15481.387      313.76236      313.76236      59577.918      59577.918      244.13252      244.13252    
Loop time of 70.3474 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.228 ns/day, 19.541 hours/ns, 14.215 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    | 70.186     | 70.186     | 70.186     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029692   | 0.029692   | 0.029692   |   0.0 |  0.04
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.11996    | 0.11996    | 0.11996    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       560000 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -15319.199     -15319.199     -15481.387     -15481.387      313.76236      313.76236      59577.918      59577.918      244.13252      244.13252    
      2000  -15321.26      -15321.26      -15478.43      -15478.43       304.05603      304.05603      59500.283      59500.283      3015.0072      3015.0072    
Loop time of 74.4908 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.692 hours/ns, 13.424 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.329     | 74.329     | 74.329     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030042   | 0.030042   | 0.030042   |   0.0 |  0.04
Output  | 7.5081e-05 | 7.5081e-05 | 7.5081e-05 |   0.0 |  0.00
Modify  | 0.12016    | 0.12016    | 0.12016    |   0.0 |  0.16
Other   |            | 0.01196    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559390 ave      559390 max      559390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559390
Ave neighs/atom = 139.8475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -15321.26      -15321.26      -15478.43      -15478.43       304.05603      304.05603      59500.283      59500.283      3015.0072      3015.0072    
      3000  -15328.468     -15328.468     -15484.222     -15484.222      301.31774      301.31774      59592.628      59592.628     -559.83471     -559.83471    
Loop time of 74.7971 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.777 hours/ns, 13.369 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.635     | 74.635     | 74.635     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029815   | 0.029815   | 0.029815   |   0.0 |  0.04
Output  | 6.896e-05  | 6.896e-05  | 6.896e-05  |   0.0 |  0.00
Modify  | 0.11991    | 0.11991    | 0.11991    |   0.0 |  0.16
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8176 ave        8176 max        8176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559640 ave      559640 max      559640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559640
Ave neighs/atom = 139.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -15328.468     -15328.468     -15484.222     -15484.222      301.31774      301.31774      59592.628      59592.628     -559.83471     -559.83471    
      4000  -15318.211     -15318.211     -15485.893     -15485.893      324.39072      324.39072      59609.51       59609.51      -970.90617     -970.90617    
Loop time of 74.9416 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.153 ns/day, 20.817 hours/ns, 13.344 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    | 74.779     | 74.779     | 74.779     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030016   | 0.030016   | 0.030016   |   0.0 |  0.04
Output  | 6.8669e-05 | 6.8669e-05 | 6.8669e-05 |   0.0 |  0.00
Modify  | 0.12026    | 0.12026    | 0.12026    |   0.0 |  0.16
Other   |            | 0.01199    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559478 ave      559478 max      559478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559478
Ave neighs/atom = 139.8695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -15318.211     -15318.211     -15485.893     -15485.893      324.39072      324.39072      59609.51       59609.51      -970.90617     -970.90617    
      5000  -15325.015     -15325.015     -15483.769     -15483.769      307.12014      307.12014      59508.709      59508.709      2181.2224      2181.2224    
Loop time of 75.0669 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.852 hours/ns, 13.321 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.904     | 74.904     | 74.904     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029922   | 0.029922   | 0.029922   |   0.0 |  0.04
Output  | 6.0303e-05 | 6.0303e-05 | 6.0303e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.16
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8178 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559490 ave      559490 max      559490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559490
Ave neighs/atom = 139.8725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.782074354587, Press = -655.602890027983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -15325.015     -15325.015     -15483.769     -15483.769      307.12014      307.12014      59508.709      59508.709      2181.2224      2181.2224    
      6000  -15322.423     -15322.423     -15482.872     -15482.872      310.39989      310.39989      59580.694      59580.694     -134.90951     -134.90951    
Loop time of 75.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.866 hours/ns, 13.312 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    | 74.952     | 74.952     | 74.952     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030003   | 0.030003   | 0.030003   |   0.0 |  0.04
Output  | 5.4683e-05 | 5.4683e-05 | 5.4683e-05 |   0.0 |  0.00
Modify  | 0.12446    | 0.12446    | 0.12446    |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559590 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.8975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.467367050451, Press = -46.4923176804072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -15322.423     -15322.423     -15482.872     -15482.872      310.39989      310.39989      59580.694      59580.694     -134.90951     -134.90951    
      7000  -15322.543     -15322.543     -15485.55      -15485.55       315.34735      315.34735      59573.383      59573.383      64.56288       64.56288     
Loop time of 75.0878 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.858 hours/ns, 13.318 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    | 74.921     | 74.921     | 74.921     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030048   | 0.030048   | 0.030048   |   0.0 |  0.04
Output  | 5.4001e-05 | 5.4001e-05 | 5.4001e-05 |   0.0 |  0.00
Modify  | 0.12497    | 0.12497    | 0.12497    |   0.0 |  0.17
Other   |            | 0.012      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8178 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559576 ave      559576 max      559576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559576
Ave neighs/atom = 139.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013036929617, Press = -17.4014353389644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -15322.543     -15322.543     -15485.55      -15485.55       315.34735      315.34735      59573.383      59573.383      64.56288       64.56288     
      8000  -15323.933     -15323.933     -15487.653     -15487.653      316.72745      316.72745      59580.93       59580.93      -411.84174     -411.84174    
Loop time of 75.0507 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.847 hours/ns, 13.324 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    | 74.884     | 74.884     | 74.884     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030041   | 0.030041   | 0.030041   |   0.0 |  0.04
Output  | 5.4513e-05 | 5.4513e-05 | 5.4513e-05 |   0.0 |  0.00
Modify  | 0.12484    | 0.12484    | 0.12484    |   0.0 |  0.17
Other   |            | 0.01193    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8173 ave        8173 max        8173 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559474 ave      559474 max      559474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559474
Ave neighs/atom = 139.8685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.307003749965, Press = -14.688941973016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -15323.933     -15323.933     -15487.653     -15487.653      316.72745      316.72745      59580.93       59580.93      -411.84174     -411.84174    
      9000  -15318.741     -15318.741     -15483.637     -15483.637      319.00154      319.00154      59579.8        59579.8        124.15312      124.15312    
Loop time of 74.9887 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.830 hours/ns, 13.335 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.821     | 74.821     | 74.821     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030222   | 0.030222   | 0.030222   |   0.0 |  0.04
Output  | 5.4282e-05 | 5.4282e-05 | 5.4282e-05 |   0.0 |  0.00
Modify  | 0.12524    | 0.12524    | 0.12524    |   0.0 |  0.17
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8177 ave        8177 max        8177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559514 ave      559514 max      559514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559514
Ave neighs/atom = 139.8785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.520874631624, Press = -14.8744875553513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -15318.741     -15318.741     -15483.637     -15483.637      319.00154      319.00154      59579.8        59579.8        124.15312      124.15312    
     10000  -15323.127     -15323.127     -15484.941     -15484.941      313.04135      313.04135      59539.178      59539.178      1105.3734      1105.3734    
Loop time of 75.0651 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.851 hours/ns, 13.322 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    | 74.898     | 74.898     | 74.898     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030151   | 0.030151   | 0.030151   |   0.0 |  0.04
Output  | 5.1086e-05 | 5.1086e-05 | 5.1086e-05 |   0.0 |  0.00
Modify  | 0.12495    | 0.12495    | 0.12495    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559532 ave      559532 max      559532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559532
Ave neighs/atom = 139.883
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.553167550414, Press = -9.33490956680966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -15323.127     -15323.127     -15484.941     -15484.941      313.04135      313.04135      59539.178      59539.178      1105.3734      1105.3734    
     11000  -15320.768     -15320.768     -15482.965     -15482.965      313.78233      313.78233      59606.707      59606.707     -643.13444     -643.13444    
Loop time of 75.0354 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.843 hours/ns, 13.327 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.87      | 74.87      | 74.87      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029973   | 0.029973   | 0.029973   |   0.0 |  0.04
Output  | 6.7828e-05 | 6.7828e-05 | 6.7828e-05 |   0.0 |  0.00
Modify  | 0.12409    | 0.12409    | 0.12409    |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559588 ave      559588 max      559588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559588
Ave neighs/atom = 139.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990192221428, Press = -14.0936451927098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -15320.768     -15320.768     -15482.965     -15482.965      313.78233      313.78233      59606.707      59606.707     -643.13444     -643.13444    
     12000  -15324.517     -15324.517     -15483.264     -15483.264      307.10694      307.10694      59635.379      59635.379     -1836.02       -1836.02      
Loop time of 75.0953 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.860 hours/ns, 13.316 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    | 74.929     | 74.929     | 74.929     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029886   | 0.029886   | 0.029886   |   0.0 |  0.04
Output  | 5.4793e-05 | 5.4793e-05 | 5.4793e-05 |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.17
Other   |            | 0.01192    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559344 ave      559344 max      559344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559344
Ave neighs/atom = 139.836
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.971071850934, Press = -10.676296936048
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -15324.517     -15324.517     -15483.264     -15483.264      307.10694      307.10694      59635.379      59635.379     -1836.02       -1836.02      
     13000  -15323.359     -15323.359     -15481.902     -15481.902      306.71257      306.71257      59610.62       59610.62      -762.63042     -762.63042    
Loop time of 75.1352 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.871 hours/ns, 13.309 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    | 74.968     | 74.968     | 74.968     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029737   | 0.029737   | 0.029737   |   0.0 |  0.04
Output  | 8.0993e-05 | 8.0993e-05 | 8.0993e-05 |   0.0 |  0.00
Modify  | 0.12519    | 0.12519    | 0.12519    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559432 ave      559432 max      559432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559432
Ave neighs/atom = 139.858
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.012426465953, Press = -5.91123352035549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -15323.359     -15323.359     -15481.902     -15481.902      306.71257      306.71257      59610.62       59610.62      -762.63042     -762.63042    
     14000  -15315.76      -15315.76      -15480.202     -15480.202      318.12417      318.12417      59656.693      59656.693     -2035.9742     -2035.9742    
Loop time of 74.9967 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.832 hours/ns, 13.334 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    | 74.83      | 74.83      | 74.83      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029916   | 0.029916   | 0.029916   |   0.0 |  0.04
Output  | 0.00011242 | 0.00011242 | 0.00011242 |   0.0 |  0.00
Modify  | 0.12476    | 0.12476    | 0.12476    |   0.0 |  0.17
Other   |            | 0.0119     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559372 ave      559372 max      559372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559372
Ave neighs/atom = 139.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.02590286432, Press = -3.19607217997397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -15315.76      -15315.76      -15480.202     -15480.202      318.12417      318.12417      59656.693      59656.693     -2035.9742     -2035.9742    
     15000  -15325.39      -15325.39      -15486.431     -15486.431      311.54469      311.54469      59594.93       59594.93      -689.82181     -689.82181    
Loop time of 75.1849 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.885 hours/ns, 13.301 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    | 75.018     | 75.018     | 75.018     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03015    | 0.03015    | 0.03015    |   0.0 |  0.04
Output  | 6.8168e-05 | 6.8168e-05 | 6.8168e-05 |   0.0 |  0.00
Modify  | 0.12502    | 0.12502    | 0.12502    |   0.0 |  0.17
Other   |            | 0.01199    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8172 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559392 ave      559392 max      559392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559392
Ave neighs/atom = 139.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.127579940163, Press = -0.437348178725414
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -15325.39      -15325.39      -15486.431     -15486.431      311.54469      311.54469      59594.93       59594.93      -689.82181     -689.82181    
     16000  -15325.424     -15325.424     -15484.563     -15484.563      307.86496      307.86496      59582.76       59582.76      -219.0535      -219.0535     
Loop time of 75.098 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.861 hours/ns, 13.316 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    | 74.931     | 74.931     | 74.931     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030251   | 0.030251   | 0.030251   |   0.0 |  0.04
Output  | 7.0122e-05 | 7.0122e-05 | 7.0122e-05 |   0.0 |  0.00
Modify  | 0.12491    | 0.12491    | 0.12491    |   0.0 |  0.17
Other   |            | 0.01194    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559472 ave      559472 max      559472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559472
Ave neighs/atom = 139.868
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.003744952822, Press = -0.811121720091189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -15325.424     -15325.424     -15484.563     -15484.563      307.86496      307.86496      59582.76       59582.76      -219.0535      -219.0535     
     17000  -15321.138     -15321.138     -15487.191     -15487.191      321.2396       321.2396       59547.277      59547.277      634.56989      634.56989    
Loop time of 75.1416 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.873 hours/ns, 13.308 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    | 74.975     | 74.975     | 74.975     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030175   | 0.030175   | 0.030175   |   0.0 |  0.04
Output  | 7.1504e-05 | 7.1504e-05 | 7.1504e-05 |   0.0 |  0.00
Modify  | 0.12461    | 0.12461    | 0.12461    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559512 ave      559512 max      559512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559512
Ave neighs/atom = 139.878
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.757513321393, Press = -1.60255464623795
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -15321.138     -15321.138     -15487.191     -15487.191      321.2396       321.2396       59547.277      59547.277      634.56989      634.56989    
     18000  -15323.066     -15323.066     -15483.603     -15483.603      310.57         310.57         59542.842      59542.842      1091.4887      1091.4887    
Loop time of 75.1173 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.866 hours/ns, 13.313 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.95      | 74.95      | 74.95      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030061   | 0.030061   | 0.030061   |   0.0 |  0.04
Output  | 6.1977e-05 | 6.1977e-05 | 6.1977e-05 |   0.0 |  0.00
Modify  | 0.12493    | 0.12493    | 0.12493    |   0.0 |  0.17
Other   |            | 0.01188    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559560 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.67009968667, Press = -3.65811782338085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -15323.066     -15323.066     -15483.603     -15483.603      310.57         310.57         59542.842      59542.842      1091.4887      1091.4887    
     19000  -15324.553     -15324.553     -15488.146     -15488.146      316.48184      316.48184      59546.993      59546.993      622.81466      622.81466    
Loop time of 74.9119 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.153 ns/day, 20.809 hours/ns, 13.349 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.745     | 74.745     | 74.745     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029902   | 0.029902   | 0.029902   |   0.0 |  0.04
Output  | 5.2459e-05 | 5.2459e-05 | 5.2459e-05 |   0.0 |  0.00
Modify  | 0.12457    | 0.12457    | 0.12457    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8182 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559530 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.8825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.680203768982, Press = -5.57872787094732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -15324.553     -15324.553     -15488.146     -15488.146      316.48184      316.48184      59546.993      59546.993      622.81466      622.81466    
     20000  -15324.271     -15324.271     -15486.189     -15486.189      313.24203      313.24203      59580.676      59580.676     -138.57491     -138.57491    
Loop time of 75.1335 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.870 hours/ns, 13.310 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.967     | 74.967     | 74.967     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029986   | 0.029986   | 0.029986   |   0.0 |  0.04
Output  | 5.7489e-05 | 5.7489e-05 | 5.7489e-05 |   0.0 |  0.00
Modify  | 0.12476    | 0.12476    | 0.12476    |   0.0 |  0.17
Other   |            | 0.01183    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559600 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.613569912241, Press = -5.03787487774343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -15324.271     -15324.271     -15486.189     -15486.189      313.24203      313.24203      59580.676      59580.676     -138.57491     -138.57491    
     21000  -15323.97      -15323.97      -15485.225     -15485.225      311.95877      311.95877      59569.784      59569.784      191.66363      191.66363    
Loop time of 75.1028 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.862 hours/ns, 13.315 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    | 74.936     | 74.936     | 74.936     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030088   | 0.030088   | 0.030088   |   0.0 |  0.04
Output  | 7.438e-05  | 7.438e-05  | 7.438e-05  |   0.0 |  0.00
Modify  | 0.12455    | 0.12455    | 0.12455    |   0.0 |  0.17
Other   |            | 0.01185    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559514 ave      559514 max      559514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559514
Ave neighs/atom = 139.8785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.455286949362, Press = -4.93527278361459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -15323.97      -15323.97      -15485.225     -15485.225      311.95877      311.95877      59569.784      59569.784      191.66363      191.66363    
     22000  -15323.321     -15323.321     -15484.093     -15484.093      311.02383      311.02383      59605.995      59605.995     -745.5107      -745.5107     
Loop time of 75.1062 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.863 hours/ns, 13.314 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    | 74.94      | 74.94      | 74.94      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029959   | 0.029959   | 0.029959   |   0.0 |  0.04
Output  | 5.8661e-05 | 5.8661e-05 | 5.8661e-05 |   0.0 |  0.00
Modify  | 0.1243     | 0.1243     | 0.1243     |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559530 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.8825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.387692397531, Press = -5.87760199997056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -15323.321     -15323.321     -15484.093     -15484.093      311.02383      311.02383      59605.995      59605.995     -745.5107      -745.5107     
     23000  -15315.221     -15315.221     -15483.159     -15483.159      324.88814      324.88814      59645.204      59645.204     -1854.3252     -1854.3252    
Loop time of 75.0116 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.837 hours/ns, 13.331 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    | 74.846     | 74.846     | 74.846     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029857   | 0.029857   | 0.029857   |   0.0 |  0.04
Output  | 5.1507e-05 | 5.1507e-05 | 5.1507e-05 |   0.0 |  0.00
Modify  | 0.12396    | 0.12396    | 0.12396    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559426 ave      559426 max      559426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559426
Ave neighs/atom = 139.8565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.374685535793, Press = -4.75810582407347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -15315.221     -15315.221     -15483.159     -15483.159      324.88814      324.88814      59645.204      59645.204     -1854.3252     -1854.3252    
     24000  -15322.097     -15322.097     -15483.645     -15483.645      312.52532      312.52532      59633.336      59633.336     -1546.7099     -1546.7099    
Loop time of 75.1398 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.872 hours/ns, 13.309 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    | 74.973     | 74.973     | 74.973     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030005   | 0.030005   | 0.030005   |   0.0 |  0.04
Output  | 5.4122e-05 | 5.4122e-05 | 5.4122e-05 |   0.0 |  0.00
Modify  | 0.12453    | 0.12453    | 0.12453    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8171 ave        8171 max        8171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559454 ave      559454 max      559454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559454
Ave neighs/atom = 139.8635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.378716370914, Press = -3.35272105918845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -15322.097     -15322.097     -15483.645     -15483.645      312.52532      312.52532      59633.336      59633.336     -1546.7099     -1546.7099    
     25000  -15326.533     -15326.533     -15487.726     -15487.726      311.8375       311.8375       59616.749      59616.749     -1547.0373     -1547.0373    
Loop time of 75.1209 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.867 hours/ns, 13.312 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    | 74.953     | 74.953     | 74.953     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030081   | 0.030081   | 0.030081   |   0.0 |  0.04
Output  | 8.1293e-05 | 8.1293e-05 | 8.1293e-05 |   0.0 |  0.00
Modify  | 0.1252     | 0.1252     | 0.1252     |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8172 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559400 ave      559400 max      559400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559400
Ave neighs/atom = 139.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.350186299096, Press = -2.88087433478027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -15326.533     -15326.533     -15487.726     -15487.726      311.8375       311.8375       59616.749      59616.749     -1547.0373     -1547.0373    
     26000  -15324.074     -15324.074     -15484.048     -15484.048      309.48154      309.48154      59629.995      59629.995     -1596.2595     -1596.2595    
Loop time of 75.0334 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.843 hours/ns, 13.327 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.866     | 74.866     | 74.866     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030006   | 0.030006   | 0.030006   |   0.0 |  0.04
Output  | 6.0163e-05 | 6.0163e-05 | 6.0163e-05 |   0.0 |  0.00
Modify  | 0.12491    | 0.12491    | 0.12491    |   0.0 |  0.17
Other   |            | 0.01191    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8179 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559544 ave      559544 max      559544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559544
Ave neighs/atom = 139.886
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.227031096916, Press = -2.34326554642074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -15324.074     -15324.074     -15484.048     -15484.048      309.48154      309.48154      59629.995      59629.995     -1596.2595     -1596.2595    
     27000  -15324.084     -15324.084     -15484.677     -15484.677      310.67939      310.67939      59602.493      59602.493     -708.47398     -708.47398    
Loop time of 74.9047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.153 ns/day, 20.807 hours/ns, 13.350 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    | 74.738     | 74.738     | 74.738     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029922   | 0.029922   | 0.029922   |   0.0 |  0.04
Output  | 5.9812e-05 | 5.9812e-05 | 5.9812e-05 |   0.0 |  0.00
Modify  | 0.12463    | 0.12463    | 0.12463    |   0.0 |  0.17
Other   |            | 0.01188    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8186 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559484 ave      559484 max      559484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559484
Ave neighs/atom = 139.871
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.208317606474, Press = -1.60884647018571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -15324.084     -15324.084     -15484.677     -15484.677      310.67939      310.67939      59602.493      59602.493     -708.47398     -708.47398    
     28000  -15322.182     -15322.182     -15484.797     -15484.797      314.58994      314.58994      59593.582      59593.582     -531.54681     -531.54681    
Loop time of 75.0766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.855 hours/ns, 13.320 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    | 74.91      | 74.91      | 74.91      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02997    | 0.02997    | 0.02997    |   0.0 |  0.04
Output  | 6.1225e-05 | 6.1225e-05 | 6.1225e-05 |   0.0 |  0.00
Modify  | 0.12498    | 0.12498    | 0.12498    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559494 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.8735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.233519985094, Press = -0.707192852813919
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -15322.182     -15322.182     -15484.797     -15484.797      314.58994      314.58994      59593.582      59593.582     -531.54681     -531.54681    
     29000  -15321.436     -15321.436     -15484.167     -15484.167      314.8139       314.8139       59554.746      59554.746      838.03858      838.03858    
Loop time of 75.1421 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.873 hours/ns, 13.308 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    | 74.976     | 74.976     | 74.976     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030113   | 0.030113   | 0.030113   |   0.0 |  0.04
Output  | 6.2217e-05 | 6.2217e-05 | 6.2217e-05 |   0.0 |  0.00
Modify  | 0.12446    | 0.12446    | 0.12446    |   0.0 |  0.17
Other   |            | 0.01183    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8172 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559492 ave      559492 max      559492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559492
Ave neighs/atom = 139.873
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.226360715808, Press = -0.93848810392924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -15321.436     -15321.436     -15484.167     -15484.167      314.8139       314.8139       59554.746      59554.746      838.03858      838.03858    
     30000  -15323.011     -15323.011     -15485.854     -15485.854      315.03202      315.03202      59561.481      59561.481      334.14494      334.14494    
Loop time of 75.1345 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.871 hours/ns, 13.309 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    | 74.968     | 74.968     | 74.968     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029995   | 0.029995   | 0.029995   |   0.0 |  0.04
Output  | 5.6205e-05 | 5.6205e-05 | 5.6205e-05 |   0.0 |  0.00
Modify  | 0.12478    | 0.12478    | 0.12478    |   0.0 |  0.17
Other   |            | 0.01188    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559478 ave      559478 max      559478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559478
Ave neighs/atom = 139.8695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.305002294913, Press = -1.99038568561116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -15323.011     -15323.011     -15485.854     -15485.854      315.03202      315.03202      59561.481      59561.481      334.14494      334.14494    
     31000  -15321.14      -15321.14      -15482.029     -15482.029      311.25189      311.25189      59547.676      59547.676      1318.5183      1318.5183    
Loop time of 75.0677 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.852 hours/ns, 13.321 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.901     | 74.901     | 74.901     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030029   | 0.030029   | 0.030029   |   0.0 |  0.04
Output  | 5.7909e-05 | 5.7909e-05 | 5.7909e-05 |   0.0 |  0.00
Modify  | 0.12461    | 0.12461    | 0.12461    |   0.0 |  0.17
Other   |            | 0.01183    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559578 ave      559578 max      559578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559578
Ave neighs/atom = 139.8945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.351642094507, Press = -1.33444038499724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -15321.14      -15321.14      -15482.029     -15482.029      311.25189      311.25189      59547.676      59547.676      1318.5183      1318.5183    
     32000  -15322.787     -15322.787     -15485.651     -15485.651      315.07116      315.07116      59581.846      59581.846     -156.29783     -156.29783    
Loop time of 75.1872 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.885 hours/ns, 13.300 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.02      | 75.02      | 75.02      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030116   | 0.030116   | 0.030116   |   0.0 |  0.04
Output  | 6.0193e-05 | 6.0193e-05 | 6.0193e-05 |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.17
Other   |            | 0.01191    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8171 ave        8171 max        8171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559520 ave      559520 max      559520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559520
Ave neighs/atom = 139.88
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.423189175139, Press = -1.60020662232555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -15322.787     -15322.787     -15485.651     -15485.651      315.07116      315.07116      59581.846      59581.846     -156.29783     -156.29783    
     33000  -15320.494     -15320.494     -15484.502     -15484.502      317.28439      317.28439      59561.093      59561.093      508.06476      508.06476    
Loop time of 75.2372 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.899 hours/ns, 13.291 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.07      | 75.07      | 75.07      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030026   | 0.030026   | 0.030026   |   0.0 |  0.04
Output  | 5.875e-05  | 5.875e-05  | 5.875e-05  |   0.0 |  0.00
Modify  | 0.12493    | 0.12493    | 0.12493    |   0.0 |  0.17
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559506 ave      559506 max      559506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559506
Ave neighs/atom = 139.8765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433152099744, Press = -1.73089804462111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -15320.494     -15320.494     -15484.502     -15484.502      317.28439      317.28439      59561.093      59561.093      508.06476      508.06476    
     34000  -15327.081     -15327.081     -15488.437     -15488.437      312.15378      312.15378      59538.395      59538.395      750.15279      750.15279    
Loop time of 75.3271 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.147 ns/day, 20.924 hours/ns, 13.275 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.16      | 75.16      | 75.16      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029993   | 0.029993   | 0.029993   |   0.0 |  0.04
Output  | 5.5094e-05 | 5.5094e-05 | 5.5094e-05 |   0.0 |  0.00
Modify  | 0.12507    | 0.12507    | 0.12507    |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559528 ave      559528 max      559528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559528
Ave neighs/atom = 139.882
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.486378664427, Press = -2.22782854351899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -15327.081     -15327.081     -15488.437     -15488.437      312.15378      312.15378      59538.395      59538.395      750.15279      750.15279    
     35000  -15322.137     -15322.137     -15484.118     -15484.118      313.36334      313.36334      59535.428      59535.428      1383.3266      1383.3266    
Loop time of 75.0226 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.840 hours/ns, 13.329 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.856     | 74.856     | 74.856     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029764   | 0.029764   | 0.029764   |   0.0 |  0.04
Output  | 5.6466e-05 | 5.6466e-05 | 5.6466e-05 |   0.0 |  0.00
Modify  | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8186 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559636 ave      559636 max      559636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559636
Ave neighs/atom = 139.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.438963867538, Press = -1.90459650227749
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -15322.137     -15322.137     -15484.118     -15484.118      313.36334      313.36334      59535.428      59535.428      1383.3266      1383.3266    
     36000  -15325.276     -15325.276     -15487.309     -15487.309      313.46364      313.46364      59522.787      59522.787      1475.6361      1475.6361    
Loop time of 75.1196 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.867 hours/ns, 13.312 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.953     | 74.953     | 74.953     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029762   | 0.029762   | 0.029762   |   0.0 |  0.04
Output  | 5.6216e-05 | 5.6216e-05 | 5.6216e-05 |   0.0 |  0.00
Modify  | 0.12502    | 0.12502    | 0.12502    |   0.0 |  0.17
Other   |            | 0.01189    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559624 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.363697721782, Press = -3.16342999737355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -15325.276     -15325.276     -15487.309     -15487.309      313.46364      313.46364      59522.787      59522.787      1475.6361      1475.6361    
     37000  -15321.728     -15321.728     -15485.037     -15485.037      315.93264      315.93264      59550.155      59550.155      855.54781      855.54781    
Loop time of 75.1044 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.862 hours/ns, 13.315 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.938     | 74.938     | 74.938     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030016   | 0.030016   | 0.030016   |   0.0 |  0.04
Output  | 6.0304e-05 | 6.0304e-05 | 6.0304e-05 |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.17
Other   |            | 0.01196    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8179 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559582 ave      559582 max      559582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559582
Ave neighs/atom = 139.8955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.364019753974, Press = -2.81435457882328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -15321.728     -15321.728     -15485.037     -15485.037      315.93264      315.93264      59550.155      59550.155      855.54781      855.54781    
     38000  -15321.78      -15321.78      -15484.135     -15484.135      314.08653      314.08653      59576.174      59576.174      194.00115      194.00115    
Loop time of 75.1101 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.864 hours/ns, 13.314 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.943     | 74.943     | 74.943     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030221   | 0.030221   | 0.030221   |   0.0 |  0.04
Output  | 5.5976e-05 | 5.5976e-05 | 5.5976e-05 |   0.0 |  0.00
Modify  | 0.12475    | 0.12475    | 0.12475    |   0.0 |  0.17
Other   |            | 0.01193    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8186 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559584 ave      559584 max      559584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559584
Ave neighs/atom = 139.896
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.316839893069, Press = -2.00429378623331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -15321.78      -15321.78      -15484.135     -15484.135      314.08653      314.08653      59576.174      59576.174      194.00115      194.00115    
     39000  -15329.896     -15329.896     -15487.348     -15487.348      304.60188      304.60188      59575.997      59575.997     -325.8269      -325.8269     
Loop time of 75.2915 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.914 hours/ns, 13.282 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.125     | 75.125     | 75.125     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030231   | 0.030231   | 0.030231   |   0.0 |  0.04
Output  | 5.7869e-05 | 5.7869e-05 | 5.7869e-05 |   0.0 |  0.00
Modify  | 0.12478    | 0.12478    | 0.12478    |   0.0 |  0.17
Other   |            | 0.01185    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559544 ave      559544 max      559544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559544
Ave neighs/atom = 139.886
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.297753437059, Press = -1.94582666444937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -15329.896     -15329.896     -15487.348     -15487.348      304.60188      304.60188      59575.997      59575.997     -325.8269      -325.8269     
     40000  -15320.548     -15320.548     -15488.024     -15488.024      323.99396      323.99396      59612.643      59612.643     -1421.4408     -1421.4408    
Loop time of 75.0113 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.836 hours/ns, 13.331 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.845     | 74.845     | 74.845     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029919   | 0.029919   | 0.029919   |   0.0 |  0.04
Output  | 5.879e-05  | 5.879e-05  | 5.879e-05  |   0.0 |  0.00
Modify  | 0.12473    | 0.12473    | 0.12473    |   0.0 |  0.17
Other   |            | 0.01185    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8176 ave        8176 max        8176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559508 ave      559508 max      559508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559508
Ave neighs/atom = 139.877
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.250840888888, Press = -1.10397371263743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -15320.548     -15320.548     -15488.024     -15488.024      323.99396      323.99396      59612.643      59612.643     -1421.4408     -1421.4408    
     41000  -15328.46      -15328.46      -15484.458     -15484.458      301.78842      301.78842      59603.265      59603.265     -839.11032     -839.11032    
Loop time of 75.1417 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.873 hours/ns, 13.308 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.975     | 74.975     | 74.975     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02996    | 0.02996    | 0.02996    |   0.0 |  0.04
Output  | 5.7398e-05 | 5.7398e-05 | 5.7398e-05 |   0.0 |  0.00
Modify  | 0.12487    | 0.12487    | 0.12487    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559538 ave      559538 max      559538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559538
Ave neighs/atom = 139.8845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.23168713942, Press = -1.3256125639166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -15328.46      -15328.46      -15484.458     -15484.458      301.78842      301.78842      59603.265      59603.265     -839.11032     -839.11032    
     42000  -15321.152     -15321.152     -15484.342     -15484.342      315.70105      315.70105      59619.419      59619.419     -1220.7484     -1220.7484    
Loop time of 75.1869 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.885 hours/ns, 13.300 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.02      | 75.02      | 75.02      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029908   | 0.029908   | 0.029908   |   0.0 |  0.04
Output  | 5.5905e-05 | 5.5905e-05 | 5.5905e-05 |   0.0 |  0.00
Modify  | 0.12466    | 0.12466    | 0.12466    |   0.0 |  0.17
Other   |            | 0.01189    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559482 ave      559482 max      559482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559482
Ave neighs/atom = 139.8705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.183089106417, Press = -0.514569487190278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -15321.152     -15321.152     -15484.342     -15484.342      315.70105      315.70105      59619.419      59619.419     -1220.7484     -1220.7484    
     43000  -15321.569     -15321.569     -15484.25      -15484.25       314.71778      314.71778      59589.269      59589.269     -415.38028     -415.38028    
Loop time of 74.7421 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.156 ns/day, 20.762 hours/ns, 13.379 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.576     | 74.576     | 74.576     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029912   | 0.029912   | 0.029912   |   0.0 |  0.04
Output  | 5.844e-05  | 5.844e-05  | 5.844e-05  |   0.0 |  0.00
Modify  | 0.12441    | 0.12441    | 0.12441    |   0.0 |  0.17
Other   |            | 0.0118     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559416 ave      559416 max      559416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559416
Ave neighs/atom = 139.854
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.166960904266, Press = -0.371241980528261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -15321.569     -15321.569     -15484.25      -15484.25       314.71778      314.71778      59589.269      59589.269     -415.38028     -415.38028    
     44000  -15322.213     -15322.213     -15485.319     -15485.319      315.53968      315.53968      59574.602      59574.602      106.98905      106.98905    
Loop time of 75.2253 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.896 hours/ns, 13.293 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.059     | 75.059     | 75.059     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029885   | 0.029885   | 0.029885   |   0.0 |  0.04
Output  | 5.881e-05  | 5.881e-05  | 5.881e-05  |   0.0 |  0.00
Modify  | 0.12489    | 0.12489    | 0.12489    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559486 ave      559486 max      559486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559486
Ave neighs/atom = 139.8715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.233928204166, Press = -1.31993988948506
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -15322.213     -15322.213     -15485.319     -15485.319      315.53968      315.53968      59574.602      59574.602      106.98905      106.98905    
     45000  -15319.13      -15319.13      -15482.26      -15482.26       315.58547      315.58547      59584.227      59584.227      18.51439       18.51439     
Loop time of 75.2634 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.906 hours/ns, 13.287 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.097     | 75.097     | 75.097     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029968   | 0.029968   | 0.029968   |   0.0 |  0.04
Output  | 5.9542e-05 | 5.9542e-05 | 5.9542e-05 |   0.0 |  0.00
Modify  | 0.12492    | 0.12492    | 0.12492    |   0.0 |  0.17
Other   |            | 0.01191    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559530 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.8825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.243421412955, Press = -0.90423858401199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -15319.13      -15319.13      -15482.26      -15482.26       315.58547      315.58547      59584.227      59584.227      18.51439       18.51439     
     46000  -15325.389     -15325.389     -15488.403     -15488.403      315.36229      315.36229      59535.46       59535.46       786.9858       786.9858     
Loop time of 75.0043 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.835 hours/ns, 13.333 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.838     | 74.838     | 74.838     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029868   | 0.029868   | 0.029868   |   0.0 |  0.04
Output  | 5.6336e-05 | 5.6336e-05 | 5.6336e-05 |   0.0 |  0.00
Modify  | 0.12483    | 0.12483    | 0.12483    |   0.0 |  0.17
Other   |            | 0.01189    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559504 ave      559504 max      559504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559504
Ave neighs/atom = 139.876
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.275408865405, Press = -1.40654844273345
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -15325.389     -15325.389     -15488.403     -15488.403      315.36229      315.36229      59535.46       59535.46       786.9858       786.9858     
     47000  -15326.682     -15326.682     -15487.241     -15487.241      310.61146      310.61146      59538.116      59538.116      825.09377      825.09377    
Loop time of 75.1086 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.864 hours/ns, 13.314 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.942     | 74.942     | 74.942     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029995   | 0.029995   | 0.029995   |   0.0 |  0.04
Output  | 5.879e-05  | 5.879e-05  | 5.879e-05  |   0.0 |  0.00
Modify  | 0.12476    | 0.12476    | 0.12476    |   0.0 |  0.17
Other   |            | 0.01191    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559546 ave      559546 max      559546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559546
Ave neighs/atom = 139.8865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.259631593689, Press = -1.88183487667305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -15326.682     -15326.682     -15487.241     -15487.241      310.61146      310.61146      59538.116      59538.116      825.09377      825.09377    
     48000  -15323.7       -15323.7       -15483.802     -15483.802      309.72652      309.72652      59529.495      59529.495      1576.508       1576.508     
Loop time of 75.2141 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.893 hours/ns, 13.295 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.047     | 75.047     | 75.047     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029968   | 0.029968   | 0.029968   |   0.0 |  0.04
Output  | 5.4743e-05 | 5.4743e-05 | 5.4743e-05 |   0.0 |  0.00
Modify  | 0.12512    | 0.12512    | 0.12512    |   0.0 |  0.17
Other   |            | 0.01188    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559580 ave      559580 max      559580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559580
Ave neighs/atom = 139.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.207454340784, Press = -0.766393571239222
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -15323.7       -15323.7       -15483.802     -15483.802      309.72652      309.72652      59529.495      59529.495      1576.508       1576.508     
     49000  -15324.156     -15324.156     -15486.021     -15486.021      313.1381       313.1381       59518.543      59518.543      1741.6442      1741.6442    
Loop time of 75.0826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.856 hours/ns, 13.319 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.916     | 74.916     | 74.916     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030113   | 0.030113   | 0.030113   |   0.0 |  0.04
Output  | 6.0263e-05 | 6.0263e-05 | 6.0263e-05 |   0.0 |  0.00
Modify  | 0.12457    | 0.12457    | 0.12457    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559494 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.8735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.207522060001, Press = -1.21949999680416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -15324.156     -15324.156     -15486.021     -15486.021      313.1381       313.1381       59518.543      59518.543      1741.6442      1741.6442    
     50000  -15321.949     -15321.949     -15485.341     -15485.341      316.0926       316.0926       59500.941      59500.941      2441.2947      2441.2947    
Loop time of 75.1446 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.873 hours/ns, 13.308 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.978     | 74.978     | 74.978     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029982   | 0.029982   | 0.029982   |   0.0 |  0.04
Output  | 5.3902e-05 | 5.3902e-05 | 5.3902e-05 |   0.0 |  0.00
Modify  | 0.12483    | 0.12483    | 0.12483    |   0.0 |  0.17
Other   |            | 0.012      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8178 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559590 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.8975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.184021940962, Press = -1.58701300878677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -15321.949     -15321.949     -15485.341     -15485.341      316.0926       316.0926       59500.941      59500.941      2441.2947      2441.2947    
     51000  -15325.439     -15325.439     -15484.479     -15484.479      307.67277      307.67277      59527.18       59527.18       1537.9892      1537.9892    
Loop time of 75.0552 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.849 hours/ns, 13.324 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    | 74.888     | 74.888     | 74.888     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029968   | 0.029968   | 0.029968   |   0.0 |  0.04
Output  | 5.8389e-05 | 5.8389e-05 | 5.8389e-05 |   0.0 |  0.00
Modify  | 0.12491    | 0.12491    | 0.12491    |   0.0 |  0.17
Other   |            | 0.01185    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559618 ave      559618 max      559618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559618
Ave neighs/atom = 139.9045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.187344868508, Press = -1.69435514712273
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -15325.439     -15325.439     -15484.479     -15484.479      307.67277      307.67277      59527.18       59527.18       1537.9892      1537.9892    
     52000  -15321.091     -15321.091     -15483.637     -15483.637      314.45713      314.45713      59623.621      59623.621     -1284.525      -1284.525     
Loop time of 75.1136 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.865 hours/ns, 13.313 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.947     | 74.947     | 74.947     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029914   | 0.029914   | 0.029914   |   0.0 |  0.04
Output  | 5.6376e-05 | 5.6376e-05 | 5.6376e-05 |   0.0 |  0.00
Modify  | 0.12451    | 0.12451    | 0.12451    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559530 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.8825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.181042027275, Press = -1.24669116118229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -15321.091     -15321.091     -15483.637     -15483.637      314.45713      314.45713      59623.621      59623.621     -1284.525      -1284.525     
     53000  -15325.256     -15325.256     -15484.263     -15484.263      307.61005      307.61005      59624.095      59624.095     -1623.0765     -1623.0765    
Loop time of 75.0779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.855 hours/ns, 13.319 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.911     | 74.911     | 74.911     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030105   | 0.030105   | 0.030105   |   0.0 |  0.04
Output  | 6.0103e-05 | 6.0103e-05 | 6.0103e-05 |   0.0 |  0.00
Modify  | 0.12477    | 0.12477    | 0.12477    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559472 ave      559472 max      559472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559472
Ave neighs/atom = 139.868
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.19043004693, Press = -1.12832866114513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -15325.256     -15325.256     -15484.263     -15484.263      307.61005      307.61005      59624.095      59624.095     -1623.0765     -1623.0765    
     54000  -15322.259     -15322.259     -15483.789     -15483.789      312.49114      312.49114      59578.47       59578.47       78.683253      78.683253    
Loop time of 75.0197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.839 hours/ns, 13.330 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    | 74.853     | 74.853     | 74.853     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029886   | 0.029886   | 0.029886   |   0.0 |  0.04
Output  | 5.2709e-05 | 5.2709e-05 | 5.2709e-05 |   0.0 |  0.00
Modify  | 0.12466    | 0.12466    | 0.12466    |   0.0 |  0.17
Other   |            | 0.0119     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559494 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.8735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.210469574998, Press = -0.60987841765873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -15322.259     -15322.259     -15483.789     -15483.789      312.49114      312.49114      59578.47       59578.47       78.683253      78.683253    
     55000  -15322.784     -15322.784     -15484.697     -15484.697      313.23299      313.23299      59580.285      59580.285     -153.01803     -153.01803    
Loop time of 75.2547 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.904 hours/ns, 13.288 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    | 75.088     | 75.088     | 75.088     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030042   | 0.030042   | 0.030042   |   0.0 |  0.04
Output  | 5.6497e-05 | 5.6497e-05 | 5.6497e-05 |   0.0 |  0.00
Modify  | 0.12493    | 0.12493    | 0.12493    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559546 ave      559546 max      559546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559546
Ave neighs/atom = 139.8865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.199312145381, Press = -1.1030037024713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -15322.784     -15322.784     -15484.697     -15484.697      313.23299      313.23299      59580.285      59580.285     -153.01803     -153.01803    
     56000  -15323.573     -15323.573     -15483.551     -15483.551      309.4883       309.4883       59592.212      59592.212     -388.89419     -388.89419    
Loop time of 75.2413 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.900 hours/ns, 13.291 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    | 75.075     | 75.075     | 75.075     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029929   | 0.029929   | 0.029929   |   0.0 |  0.04
Output  | 6.3389e-05 | 6.3389e-05 | 6.3389e-05 |   0.0 |  0.00
Modify  | 0.12486    | 0.12486    | 0.12486    |   0.0 |  0.17
Other   |            | 0.01188    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559508 ave      559508 max      559508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559508
Ave neighs/atom = 139.877
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.219148153484, Press = -1.38603764113691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -15323.573     -15323.573     -15483.551     -15483.551      309.4883       309.4883       59592.212      59592.212     -388.89419     -388.89419    
     57000  -15318.08      -15318.08      -15485.054     -15485.054      323.02366      323.02366      59655.487      59655.487     -2318.1631     -2318.1631    
Loop time of 74.8743 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.154 ns/day, 20.798 hours/ns, 13.356 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    | 74.708     | 74.708     | 74.708     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029911   | 0.029911   | 0.029911   |   0.0 |  0.04
Output  | 5.9983e-05 | 5.9983e-05 | 5.9983e-05 |   0.0 |  0.00
Modify  | 0.12475    | 0.12475    | 0.12475    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559466 ave      559466 max      559466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559466
Ave neighs/atom = 139.8665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.239041695047, Press = -1.29664134179112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -15318.08      -15318.08      -15485.054     -15485.054      323.02366      323.02366      59655.487      59655.487     -2318.1631     -2318.1631    
     58000  -15326.182     -15326.182     -15484.319     -15484.319      305.92701      305.92701      59637.308      59637.308     -1800.7643     -1800.7643    
Loop time of 75.1635 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.879 hours/ns, 13.304 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    | 74.997     | 74.997     | 74.997     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029923   | 0.029923   | 0.029923   |   0.0 |  0.04
Output  | 5.5203e-05 | 5.5203e-05 | 5.5203e-05 |   0.0 |  0.00
Modify  | 0.12487    | 0.12487    | 0.12487    |   0.0 |  0.17
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8177 ave        8177 max        8177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559412 ave      559412 max      559412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559412
Ave neighs/atom = 139.853
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.253468866631, Press = -0.899429021166409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -15326.182     -15326.182     -15484.319     -15484.319      305.92701      305.92701      59637.308      59637.308     -1800.7643     -1800.7643    
     59000  -15320.323     -15320.323     -15480.928     -15480.928      310.70245      310.70245      59622.394      59622.394     -1057.6203     -1057.6203    
Loop time of 75.1728 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.881 hours/ns, 13.303 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.005     | 75.005     | 75.005     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03019    | 0.03019    | 0.03019    |   0.0 |  0.04
Output  | 5.8049e-05 | 5.8049e-05 | 5.8049e-05 |   0.0 |  0.00
Modify  | 0.12528    | 0.12528    | 0.12528    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559456 ave      559456 max      559456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559456
Ave neighs/atom = 139.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.273105028054, Press = -0.783026439397027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -15320.323     -15320.323     -15480.928     -15480.928      310.70245      310.70245      59622.394      59622.394     -1057.6203     -1057.6203    
     60000  -15323.462     -15323.462     -15485.058     -15485.058      312.619        312.619        59592.196      59592.196     -498.74358     -498.74358    
Loop time of 74.9654 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.153 ns/day, 20.824 hours/ns, 13.339 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.799     | 74.799     | 74.799     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029948   | 0.029948   | 0.029948   |   0.0 |  0.04
Output  | 6.7447e-05 | 6.7447e-05 | 6.7447e-05 |   0.0 |  0.00
Modify  | 0.12469    | 0.12469    | 0.12469    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8172 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559488 ave      559488 max      559488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559488
Ave neighs/atom = 139.872
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.271464601981, Press = -0.387731229519405
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -15323.462     -15323.462     -15485.058     -15485.058      312.619        312.619        59592.196      59592.196     -498.74358     -498.74358    
     61000  -15327.671     -15327.671     -15491.45      -15491.45       316.84195      316.84195      59575.688      59575.688     -764.53155     -764.53155    
Loop time of 75.2518 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.903 hours/ns, 13.289 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    | 75.085     | 75.085     | 75.085     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030035   | 0.030035   | 0.030035   |   0.0 |  0.04
Output  | 6.1024e-05 | 6.1024e-05 | 6.1024e-05 |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559462 ave      559462 max      559462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559462
Ave neighs/atom = 139.8655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.267801378113, Press = -0.689092761462001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -15327.671     -15327.671     -15491.45      -15491.45       316.84195      316.84195      59575.688      59575.688     -764.53155     -764.53155    
     62000  -15320.949     -15320.949     -15484.501     -15484.501      316.40236      316.40236      59552.359      59552.359      872.43931      872.43931    
Loop time of 75.2077 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.891 hours/ns, 13.297 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.041     | 75.041     | 75.041     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029992   | 0.029992   | 0.029992   |   0.0 |  0.04
Output  | 4.5446e-05 | 4.5446e-05 | 4.5446e-05 |   0.0 |  0.00
Modify  | 0.12489    | 0.12489    | 0.12489    |   0.0 |  0.17
Other   |            | 0.01187    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8179 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559594 ave      559594 max      559594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559594
Ave neighs/atom = 139.8985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.24069282487, Press = -0.527377800686516
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -15320.949     -15320.949     -15484.501     -15484.501      316.40236      316.40236      59552.359      59552.359      872.43931      872.43931    
     63000  -15323.915     -15323.915     -15486.671     -15486.671      314.86403      314.86403      59556.262      59556.262      530.39285      530.39285    
Loop time of 74.9326 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.153 ns/day, 20.815 hours/ns, 13.345 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.767     | 74.767     | 74.767     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029916   | 0.029916   | 0.029916   |   0.0 |  0.04
Output  | 5.0054e-05 | 5.0054e-05 | 5.0054e-05 |   0.0 |  0.00
Modify  | 0.12428    | 0.12428    | 0.12428    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559566 ave      559566 max      559566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559566
Ave neighs/atom = 139.8915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.237070965112, Press = -1.33165419862731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -15323.915     -15323.915     -15486.671     -15486.671      314.86403      314.86403      59556.262      59556.262      530.39285      530.39285    
     64000  -15325.202     -15325.202     -15485.726     -15485.726      310.54387      310.54387      59562.756      59562.756      390.18382      390.18382    
Loop time of 74.9912 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.152 ns/day, 20.831 hours/ns, 13.335 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.825     | 74.825     | 74.825     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030038   | 0.030038   | 0.030038   |   0.0 |  0.04
Output  | 5.821e-05  | 5.821e-05  | 5.821e-05  |   0.0 |  0.00
Modify  | 0.12442    | 0.12442    | 0.12442    |   0.0 |  0.17
Other   |            | 0.0118     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8182 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559604 ave      559604 max      559604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559604
Ave neighs/atom = 139.901
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.272285244537, Press = -0.637644391697559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -15325.202     -15325.202     -15485.726     -15485.726      310.54387      310.54387      59562.756      59562.756      390.18382      390.18382    
     65000  -15321.884     -15321.884     -15485.279     -15485.279      316.09958      316.09958      59563.677      59563.677      462.2499       462.2499     
Loop time of 75.0908 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.151 ns/day, 20.859 hours/ns, 13.317 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.925     | 74.925     | 74.925     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029983   | 0.029983   | 0.029983   |   0.0 |  0.04
Output  | 4.9914e-05 | 4.9914e-05 | 4.9914e-05 |   0.0 |  0.00
Modify  | 0.1243     | 0.1243     | 0.1243     |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559560 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.274582717197, Press = -0.407240224957607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -15321.884     -15321.884     -15485.279     -15485.279      316.09958      316.09958      59563.677      59563.677      462.2499       462.2499     
     66000  -15326.453     -15326.453     -15486.71      -15486.71       310.02845      310.02845      59565.56       59565.56       218.7885       218.7885     
Loop time of 74.4976 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.694 hours/ns, 13.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.332     | 74.332     | 74.332     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029858   | 0.029858   | 0.029858   |   0.0 |  0.04
Output  | 4.81e-05   | 4.81e-05   | 4.81e-05   |   0.0 |  0.00
Modify  | 0.12407    | 0.12407    | 0.12407    |   0.0 |  0.17
Other   |            | 0.01185    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559536 ave      559536 max      559536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559536
Ave neighs/atom = 139.884
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.248564104216, Press = -0.521698532377785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -15326.453     -15326.453     -15486.71      -15486.71       310.02845      310.02845      59565.56       59565.56       218.7885       218.7885     
     67000  -15322.52      -15322.52      -15485.964     -15485.964      316.19237      316.19237      59557.952      59557.952      382.42086      382.42086    
Loop time of 75.1757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.149 ns/day, 20.882 hours/ns, 13.302 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.01      | 75.01      | 75.01      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029986   | 0.029986   | 0.029986   |   0.0 |  0.04
Output  | 5.0375e-05 | 5.0375e-05 | 5.0375e-05 |   0.0 |  0.00
Modify  | 0.1241     | 0.1241     | 0.1241     |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559588 ave      559588 max      559588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559588
Ave neighs/atom = 139.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.219919467782, Press = -0.43379003108475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -15322.52      -15322.52      -15485.964     -15485.964      316.19237      316.19237      59557.952      59557.952      382.42086      382.42086    
     68000  -15323.094     -15323.094     -15486.132     -15486.132      315.40807      315.40807      59557.764      59557.764      473.08213      473.08213    
Loop time of 75.1485 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.150 ns/day, 20.875 hours/ns, 13.307 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.982     | 74.982     | 74.982     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030032   | 0.030032   | 0.030032   |   0.0 |  0.04
Output  | 5.1477e-05 | 5.1477e-05 | 5.1477e-05 |   0.0 |  0.00
Modify  | 0.12445    | 0.12445    | 0.12445    |   0.0 |  0.17
Other   |            | 0.0118     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8186 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559516 ave      559516 max      559516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559516
Ave neighs/atom = 139.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
59576.8118379953

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0