# 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.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.024436 33.024436 33.024436)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (33.024436 33.024436 33.024436)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimJungLee_2010_FeNbC__MO_072689718616_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36016.8901176252 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_072689718616_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14859.085     -14859.085     -14940         -14940          313.15         313.15         36016.89       36016.89       2399.6435      2399.6435    
      1000  -14776.173     -14776.173     -14862.503     -14862.503      334.10581      334.10581      36183.223      36183.223      914.80464      914.80464    
Loop time of 12.8352 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.732 ns/day, 3.565 hours/ns, 77.911 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.758     | 12.758     | 12.758     |   0.0 | 99.40
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.011236   | 0.011236   | 0.011236   |   0.0 |  0.09
Output  | 0.00018082 | 0.00018082 | 0.00018082 |   0.0 |  0.00
Modify  | 0.060675   | 0.060675   | 0.060675   |   0.0 |  0.47
Other   |            | 0.005057   |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -14776.173     -14776.173     -14862.503     -14862.503      334.10581      334.10581      36183.223      36183.223      914.80464      914.80464    
      2000  -14774.628     -14774.628     -14851.91      -14851.91       299.09291      299.09291      36225.328      36225.328     -582.60565     -582.60565    
Loop time of 23.8439 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.624 ns/day, 6.623 hours/ns, 41.940 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.766     | 23.766     | 23.766     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012847   | 0.012847   | 0.012847   |   0.0 |  0.05
Output  | 8.02e-05   | 8.02e-05   | 8.02e-05   |   0.0 |  0.00
Modify  | 0.060095   | 0.060095   | 0.060095   |   0.0 |  0.25
Other   |            | 0.005221   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3375 ave        3375 max        3375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121034 ave      121034 max      121034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121034
Ave neighs/atom = 60.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -14774.628     -14774.628     -14851.91      -14851.91       299.09291      299.09291      36225.328      36225.328     -582.60565     -582.60565    
      3000  -14778.295     -14778.295     -14858.233     -14858.233      309.36848      309.36848      36218.181      36218.181     -852.28142     -852.28142    
Loop time of 24.1215 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.582 ns/day, 6.700 hours/ns, 41.457 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.043     | 24.043     | 24.043     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012596   | 0.012596   | 0.012596   |   0.0 |  0.05
Output  | 8.1402e-05 | 8.1402e-05 | 8.1402e-05 |   0.0 |  0.00
Modify  | 0.060359   | 0.060359   | 0.060359   |   0.0 |  0.25
Other   |            | 0.005151   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3341 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120914 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -14778.295     -14778.295     -14858.233     -14858.233      309.36848      309.36848      36218.181      36218.181     -852.28142     -852.28142    
      4000  -14773.893     -14773.893     -14855.658     -14855.658      316.43701      316.43701      36228.463      36228.463     -963.53976     -963.53976    
Loop time of 24.1475 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.578 ns/day, 6.708 hours/ns, 41.412 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.07      | 24.07      | 24.07      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01254    | 0.01254    | 0.01254    |   0.0 |  0.05
Output  | 4.2389e-05 | 4.2389e-05 | 4.2389e-05 |   0.0 |  0.00
Modify  | 0.060017   | 0.060017   | 0.060017   |   0.0 |  0.25
Other   |            | 0.005061   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3348 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120970 ave      120970 max      120970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120970
Ave neighs/atom = 60.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -14773.893     -14773.893     -14855.658     -14855.658      316.43701      316.43701      36228.463      36228.463     -963.53976     -963.53976    
      5000  -14777.956     -14777.956     -14857.781     -14857.781      308.93108      308.93108      36215.993      36215.993     -620.00985     -620.00985    
Loop time of 24.0735 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.589 ns/day, 6.687 hours/ns, 41.540 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.995     | 23.995     | 23.995     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012506   | 0.012506   | 0.012506   |   0.0 |  0.05
Output  | 2.8624e-05 | 2.8624e-05 | 2.8624e-05 |   0.0 |  0.00
Modify  | 0.060495   | 0.060495   | 0.060495   |   0.0 |  0.25
Other   |            | 0.005068   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3349 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120892 ave      120892 max      120892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120892
Ave neighs/atom = 60.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.247361736189, Press = 462.973144776694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -14777.956     -14777.956     -14857.781     -14857.781      308.93108      308.93108      36215.993      36215.993     -620.00985     -620.00985    
      6000  -14772.959     -14772.959     -14854.255     -14854.255      314.6226       314.6226       36178.05       36178.05       1687.8666      1687.8666    
Loop time of 24.1051 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.584 ns/day, 6.696 hours/ns, 41.485 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.025     | 24.025     | 24.025     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012586   | 0.012586   | 0.012586   |   0.0 |  0.05
Output  | 2.5588e-05 | 2.5588e-05 | 2.5588e-05 |   0.0 |  0.00
Modify  | 0.062652   | 0.062652   | 0.062652   |   0.0 |  0.26
Other   |            | 0.005091   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3352 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120974 ave      120974 max      120974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120974
Ave neighs/atom = 60.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.97473866974, Press = 51.9777364553537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -14772.959     -14772.959     -14854.255     -14854.255      314.6226       314.6226       36178.05       36178.05       1687.8666      1687.8666    
      7000  -14777.056     -14777.056     -14858.757     -14858.757      316.19381      316.19381      36155.977      36155.977      2657.1614      2657.1614    
Loop time of 24.3607 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.547 ns/day, 6.767 hours/ns, 41.050 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.28      | 24.28      | 24.28      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012884   | 0.012884   | 0.012884   |   0.0 |  0.05
Output  | 2.1761e-05 | 2.1761e-05 | 2.1761e-05 |   0.0 |  0.00
Modify  | 0.063071   | 0.063071   | 0.063071   |   0.0 |  0.26
Other   |            | 0.005139   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3396 ave        3396 max        3396 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121138 ave      121138 max      121138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121138
Ave neighs/atom = 60.569
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.168697665313, Press = -3.79602982712903
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -14777.056     -14777.056     -14858.757     -14858.757      316.19381      316.19381      36155.977      36155.977      2657.1614      2657.1614    
      8000  -14772.803     -14772.803     -14857.804     -14857.804      328.96082      328.96082      36210.679      36210.679     -181.75267     -181.75267    
Loop time of 24.3111 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.554 ns/day, 6.753 hours/ns, 41.133 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.23      | 24.23      | 24.23      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012833   | 0.012833   | 0.012833   |   0.0 |  0.05
Output  | 2.9596e-05 | 2.9596e-05 | 2.9596e-05 |   0.0 |  0.00
Modify  | 0.062833   | 0.062833   | 0.062833   |   0.0 |  0.26
Other   |            | 0.005141   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3406 ave        3406 max        3406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121136 ave      121136 max      121136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121136
Ave neighs/atom = 60.568
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.43028005388, Press = -7.47234974198121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -14772.803     -14772.803     -14857.804     -14857.804      328.96082      328.96082      36210.679      36210.679     -181.75267     -181.75267    
      9000  -14777.314     -14777.314     -14857.694     -14857.694      311.07897      311.07897      36216.749      36216.749     -749.86389     -749.86389    
Loop time of 24.2721 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.560 ns/day, 6.742 hours/ns, 41.200 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.191     | 24.191     | 24.191     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012862   | 0.012862   | 0.012862   |   0.0 |  0.05
Output  | 2.1721e-05 | 2.1721e-05 | 2.1721e-05 |   0.0 |  0.00
Modify  | 0.063297   | 0.063297   | 0.063297   |   0.0 |  0.26
Other   |            | 0.005179   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3396 ave        3396 max        3396 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121102 ave      121102 max      121102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121102
Ave neighs/atom = 60.551
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.304221865446, Press = -0.724224104111612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -14777.314     -14777.314     -14857.694     -14857.694      311.07897      311.07897      36216.749      36216.749     -749.86389     -749.86389    
     10000  -14781.168     -14781.168     -14859.122     -14859.122      301.68988      301.68988      36202.257      36202.257     -83.758661     -83.758661    
Loop time of 24.3811 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.544 ns/day, 6.773 hours/ns, 41.015 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.3       | 24.3       | 24.3       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012616   | 0.012616   | 0.012616   |   0.0 |  0.05
Output  | 2.9986e-05 | 2.9986e-05 | 2.9986e-05 |   0.0 |  0.00
Modify  | 0.063166   | 0.063166   | 0.063166   |   0.0 |  0.26
Other   |            | 0.005137   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3331 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120916 ave      120916 max      120916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120916
Ave neighs/atom = 60.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.994628544219, Press = 3.61853864317187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -14781.168     -14781.168     -14859.122     -14859.122      301.68988      301.68988      36202.257      36202.257     -83.758661     -83.758661    
     11000  -14774.482     -14774.482     -14857.557     -14857.557      321.51133      321.51133      36212.645      36212.645     -286.4139      -286.4139     
Loop time of 24.4198 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.538 ns/day, 6.783 hours/ns, 40.950 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.338     | 24.338     | 24.338     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012829   | 0.012829   | 0.012829   |   0.0 |  0.05
Output  | 2.699e-05  | 2.699e-05  | 2.699e-05  |   0.0 |  0.00
Modify  | 0.06355    | 0.06355    | 0.06355    |   0.0 |  0.26
Other   |            | 0.005165   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3341 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120902 ave      120902 max      120902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120902
Ave neighs/atom = 60.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.52970224669, Press = 2.80068271308783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -14774.482     -14774.482     -14857.557     -14857.557      321.51133      321.51133      36212.645      36212.645     -286.4139      -286.4139     
     12000  -14778.936     -14778.936     -14856.228     -14856.228      299.12669      299.12669      36202.453      36202.453      115.18994      115.18994    
Loop time of 24.3616 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.547 ns/day, 6.767 hours/ns, 41.048 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.28      | 24.28      | 24.28      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012829   | 0.012829   | 0.012829   |   0.0 |  0.05
Output  | 2.5538e-05 | 2.5538e-05 | 2.5538e-05 |   0.0 |  0.00
Modify  | 0.063596   | 0.063596   | 0.063596   |   0.0 |  0.26
Other   |            | 0.005148   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3360 ave        3360 max        3360 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120980 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.189175110444, Press = 1.50756964024899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -14778.936     -14778.936     -14856.228     -14856.228      299.12669      299.12669      36202.453      36202.453      115.18994      115.18994    
     13000  -14774.323     -14774.323     -14855.414     -14855.414      313.83042      313.83042      36219.959      36219.959     -475.88156     -475.88156    
Loop time of 24.3345 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.551 ns/day, 6.760 hours/ns, 41.094 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.253     | 24.253     | 24.253     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012888   | 0.012888   | 0.012888   |   0.0 |  0.05
Output  | 2.1921e-05 | 2.1921e-05 | 2.1921e-05 |   0.0 |  0.00
Modify  | 0.063448   | 0.063448   | 0.063448   |   0.0 |  0.26
Other   |            | 0.005171   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3402 ave        3402 max        3402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121014 ave      121014 max      121014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121014
Ave neighs/atom = 60.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.112222280811, Press = 0.278955973963859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -14774.323     -14774.323     -14855.414     -14855.414      313.83042      313.83042      36219.959      36219.959     -475.88156     -475.88156    
     14000  -14778.821     -14778.821     -14859.594     -14859.594      312.59956      312.59956      36225.425      36225.425     -1162.8302     -1162.8302    
Loop time of 24.2979 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.556 ns/day, 6.749 hours/ns, 41.156 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.217     | 24.217     | 24.217     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012815   | 0.012815   | 0.012815   |   0.0 |  0.05
Output  | 2.147e-05  | 2.147e-05  | 2.147e-05  |   0.0 |  0.00
Modify  | 0.063393   | 0.063393   | 0.063393   |   0.0 |  0.26
Other   |            | 0.005162   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3378 ave        3378 max        3378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120984 ave      120984 max      120984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120984
Ave neighs/atom = 60.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.95368808945, Press = 0.958593588198138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -14778.821     -14778.821     -14859.594     -14859.594      312.59956      312.59956      36225.425      36225.425     -1162.8302     -1162.8302    
     15000  -14776.883     -14776.883     -14857.772     -14857.772      313.04931      313.04931      36229.767      36229.767     -1358.2479     -1358.2479    
Loop time of 24.3773 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.544 ns/day, 6.771 hours/ns, 41.022 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.296     | 24.296     | 24.296     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012697   | 0.012697   | 0.012697   |   0.0 |  0.05
Output  | 2.8333e-05 | 2.8333e-05 | 2.8333e-05 |   0.0 |  0.00
Modify  | 0.063217   | 0.063217   | 0.063217   |   0.0 |  0.26
Other   |            | 0.005171   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3361 ave        3361 max        3361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120956 ave      120956 max      120956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120956
Ave neighs/atom = 60.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.16308553655, Press = 4.19864681125005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -14776.883     -14776.883     -14857.772     -14857.772      313.04931      313.04931      36229.767      36229.767     -1358.2479     -1358.2479    
     16000  -14773.104     -14773.104     -14855.546     -14855.546      319.06028      319.06028      36196.399      36196.399      728.68875      728.68875    
Loop time of 24.3025 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.555 ns/day, 6.751 hours/ns, 41.148 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    | 24.221     | 24.221     | 24.221     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012722   | 0.012722   | 0.012722   |   0.0 |  0.05
Output  | 2.3584e-05 | 2.3584e-05 | 2.3584e-05 |   0.0 |  0.00
Modify  | 0.063306   | 0.063306   | 0.063306   |   0.0 |  0.26
Other   |            | 0.005116   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3329 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120850 ave      120850 max      120850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120850
Ave neighs/atom = 60.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.288153218813, Press = 4.80291676781954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -14773.104     -14773.104     -14855.546     -14855.546      319.06028      319.06028      36196.399      36196.399      728.68875      728.68875    
     17000  -14777.384     -14777.384     -14856.98      -14856.98       308.04307      308.04307      36145.194      36145.194      3282.6452      3282.6452    
Loop time of 24.2816 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.558 ns/day, 6.745 hours/ns, 41.183 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.2       | 24.2       | 24.2       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012674   | 0.012674   | 0.012674   |   0.0 |  0.05
Output  | 2.7181e-05 | 2.7181e-05 | 2.7181e-05 |   0.0 |  0.00
Modify  | 0.063281   | 0.063281   | 0.063281   |   0.0 |  0.26
Other   |            | 0.005145   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121046 ave      121046 max      121046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121046
Ave neighs/atom = 60.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453820146836, Press = 1.8835411691709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -14777.384     -14777.384     -14856.98      -14856.98       308.04307      308.04307      36145.194      36145.194      3282.6452      3282.6452    
     18000  -14775.828     -14775.828     -14859.883     -14859.883      325.30225      325.30225      36187.427      36187.427      823.14869      823.14869    
Loop time of 24.2286 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.566 ns/day, 6.730 hours/ns, 41.274 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.147     | 24.147     | 24.147     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012786   | 0.012786   | 0.012786   |   0.0 |  0.05
Output  | 2.2092e-05 | 2.2092e-05 | 2.2092e-05 |   0.0 |  0.00
Modify  | 0.063147   | 0.063147   | 0.063147   |   0.0 |  0.26
Other   |            | 0.005122   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3358 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121220 ave      121220 max      121220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121220
Ave neighs/atom = 60.61
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.499357158651, Press = -2.69302235901623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -14775.828     -14775.828     -14859.883     -14859.883      325.30225      325.30225      36187.427      36187.427      823.14869      823.14869    
     19000  -14772.321     -14772.321     -14856.486     -14856.486      325.72767      325.72767      36225.084      36225.084     -851.53818     -851.53818    
Loop time of 24.2597 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.561 ns/day, 6.739 hours/ns, 41.221 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.179     | 24.179     | 24.179     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012657   | 0.012657   | 0.012657   |   0.0 |  0.05
Output  | 2.1299e-05 | 2.1299e-05 | 2.1299e-05 |   0.0 |  0.00
Modify  | 0.062882   | 0.062882   | 0.062882   |   0.0 |  0.26
Other   |            | 0.005086   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3341 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121040 ave      121040 max      121040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121040
Ave neighs/atom = 60.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.606480814689, Press = -0.648887483341994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -14772.321     -14772.321     -14856.486     -14856.486      325.72767      325.72767      36225.084      36225.084     -851.53818     -851.53818    
     20000  -14776.523     -14776.523     -14856.018     -14856.018      307.65576      307.65576      36216.545      36216.545     -513.89652     -513.89652    
Loop time of 24.2474 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.563 ns/day, 6.735 hours/ns, 41.242 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.166     | 24.166     | 24.166     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012754   | 0.012754   | 0.012754   |   0.0 |  0.05
Output  | 2.9515e-05 | 2.9515e-05 | 2.9515e-05 |   0.0 |  0.00
Modify  | 0.063095   | 0.063095   | 0.063095   |   0.0 |  0.26
Other   |            | 0.005138   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3385 ave        3385 max        3385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120996 ave      120996 max      120996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120996
Ave neighs/atom = 60.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.630239207998, Press = 0.894419293871479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -14776.523     -14776.523     -14856.018     -14856.018      307.65576      307.65576      36216.545      36216.545     -513.89652     -513.89652    
     21000  -14780.848     -14780.848     -14859.271     -14859.271      303.50606      303.50606      36199.844      36199.844      94.828251      94.828251    
Loop time of 24.1875 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.572 ns/day, 6.719 hours/ns, 41.344 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.107     | 24.107     | 24.107     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012758   | 0.012758   | 0.012758   |   0.0 |  0.05
Output  | 2.4496e-05 | 2.4496e-05 | 2.4496e-05 |   0.0 |  0.00
Modify  | 0.062879   | 0.062879   | 0.062879   |   0.0 |  0.26
Other   |            | 0.005112   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3381 ave        3381 max        3381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121004 ave      121004 max      121004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121004
Ave neighs/atom = 60.502
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.535074614303, Press = 1.37566132827548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -14780.848     -14780.848     -14859.271     -14859.271      303.50606      303.50606      36199.844      36199.844      94.828251      94.828251    
     22000  -14775.549     -14775.549     -14858.805     -14858.805      322.20623      322.20623      36189.865      36189.865      817.97921      817.97921    
Loop time of 24.2306 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.566 ns/day, 6.731 hours/ns, 41.270 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.15      | 24.15      | 24.15      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012742   | 0.012742   | 0.012742   |   0.0 |  0.05
Output  | 2.7621e-05 | 2.7621e-05 | 2.7621e-05 |   0.0 |  0.00
Modify  | 0.062687   | 0.062687   | 0.062687   |   0.0 |  0.26
Other   |            | 0.005084   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3370 ave        3370 max        3370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121068 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.395894805302, Press = 0.646741334357134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -14775.549     -14775.549     -14858.805     -14858.805      322.20623      322.20623      36189.865      36189.865      817.97921      817.97921    
     23000  -14779.207     -14779.207     -14859.981     -14859.981      312.60165      312.60165      36183.611      36183.611      980.51322      980.51322    
Loop time of 24.2856 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.558 ns/day, 6.746 hours/ns, 41.177 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.204     | 24.204     | 24.204     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012931   | 0.012931   | 0.012931   |   0.0 |  0.05
Output  | 2.1651e-05 | 2.1651e-05 | 2.1651e-05 |   0.0 |  0.00
Modify  | 0.063355   | 0.063355   | 0.063355   |   0.0 |  0.26
Other   |            | 0.005178   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3379 ave        3379 max        3379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121032 ave      121032 max      121032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121032
Ave neighs/atom = 60.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.224094687381, Press = -0.972831037749988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -14779.207     -14779.207     -14859.981     -14859.981      312.60165      312.60165      36183.611      36183.611      980.51322      980.51322    
     24000  -14777.654     -14777.654     -14857.857     -14857.857      310.39226      310.39226      36226.407      36226.407     -1120.2799     -1120.2799    
Loop time of 24.3196 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.553 ns/day, 6.755 hours/ns, 41.119 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.238     | 24.238     | 24.238     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012637   | 0.012637   | 0.012637   |   0.0 |  0.05
Output  | 2.136e-05  | 2.136e-05  | 2.136e-05  |   0.0 |  0.00
Modify  | 0.063355   | 0.063355   | 0.063355   |   0.0 |  0.26
Other   |            | 0.005124   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3319 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120986 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120986
Ave neighs/atom = 60.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.258582843307, Press = -2.0498276176743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -14777.654     -14777.654     -14857.857     -14857.857      310.39226      310.39226      36226.407      36226.407     -1120.2799     -1120.2799    
     25000  -14772.778     -14772.778     -14854.847     -14854.847      317.61587      317.61587      36260.524      36260.524     -2612.2877     -2612.2877    
Loop time of 24.4065 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.540 ns/day, 6.780 hours/ns, 40.973 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.325     | 24.325     | 24.325     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012668   | 0.012668   | 0.012668   |   0.0 |  0.05
Output  | 3.3182e-05 | 3.3182e-05 | 3.3182e-05 |   0.0 |  0.00
Modify  | 0.063475   | 0.063475   | 0.063475   |   0.0 |  0.26
Other   |            | 0.005114   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3312 ave        3312 max        3312 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120930 ave      120930 max      120930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120930
Ave neighs/atom = 60.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.314446003579, Press = 0.228088392913679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -14772.778     -14772.778     -14854.847     -14854.847      317.61587      317.61587      36260.524      36260.524     -2612.2877     -2612.2877    
     26000  -14777.827     -14777.827     -14856.867     -14856.867      305.89406      305.89406      36219.376      36219.376     -765.76632     -765.76632    
Loop time of 24.2968 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.556 ns/day, 6.749 hours/ns, 41.158 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.216     | 24.216     | 24.216     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012639   | 0.012639   | 0.012639   |   0.0 |  0.05
Output  | 2.16e-05   | 2.16e-05   | 2.16e-05   |   0.0 |  0.00
Modify  | 0.062991   | 0.062991   | 0.062991   |   0.0 |  0.26
Other   |            | 0.005125   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3348 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120868 ave      120868 max      120868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120868
Ave neighs/atom = 60.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.414539135736, Press = 1.97794589324828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -14777.827     -14777.827     -14856.867     -14856.867      305.89406      305.89406      36219.376      36219.376     -765.76632     -765.76632    
     27000  -14770.846     -14770.846     -14853.348     -14853.348      319.29039      319.29039      36204.192      36204.192      496.22602      496.22602    
Loop time of 24.0755 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.589 ns/day, 6.688 hours/ns, 41.536 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.995     | 23.995     | 23.995     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012658   | 0.012658   | 0.012658   |   0.0 |  0.05
Output  | 2.9074e-05 | 2.9074e-05 | 2.9074e-05 |   0.0 |  0.00
Modify  | 0.062871   | 0.062871   | 0.062871   |   0.0 |  0.26
Other   |            | 0.005107   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3357 ave        3357 max        3357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120928 ave      120928 max      120928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120928
Ave neighs/atom = 60.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50269987574, Press = 1.11908518583742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -14770.846     -14770.846     -14853.348     -14853.348      319.29039      319.29039      36204.192      36204.192      496.22602      496.22602    
     28000  -14775.918     -14775.918     -14856.502     -14856.502      311.86717      311.86717      36190.448      36190.448      929.62605      929.62605    
Loop time of 24.0609 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.591 ns/day, 6.684 hours/ns, 41.561 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.98      | 23.98      | 23.98      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012719   | 0.012719   | 0.012719   |   0.0 |  0.05
Output  | 2.145e-05  | 2.145e-05  | 2.145e-05  |   0.0 |  0.00
Modify  | 0.062619   | 0.062619   | 0.062619   |   0.0 |  0.26
Other   |            | 0.005121   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3399 ave        3399 max        3399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121096 ave      121096 max      121096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121096
Ave neighs/atom = 60.548
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.503234564817, Press = 0.440963664772277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -14775.918     -14775.918     -14856.502     -14856.502      311.86717      311.86717      36190.448      36190.448      929.62605      929.62605    
     29000  -14779.152     -14779.152     -14856.85      -14856.85       300.69911      300.69911      36199.54       36199.54       321.66503      321.66503    
Loop time of 24.0908 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.586 ns/day, 6.692 hours/ns, 41.510 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.01      | 24.01      | 24.01      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01277    | 0.01277    | 0.01277    |   0.0 |  0.05
Output  | 3.1999e-05 | 3.1999e-05 | 3.1999e-05 |   0.0 |  0.00
Modify  | 0.062813   | 0.062813   | 0.062813   |   0.0 |  0.26
Other   |            | 0.005099   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3362 ave        3362 max        3362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120982 ave      120982 max      120982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120982
Ave neighs/atom = 60.491
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507981588846, Press = -0.200763196443816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -14779.152     -14779.152     -14856.85      -14856.85       300.69911      300.69911      36199.54       36199.54       321.66503      321.66503    
     30000  -14774.061     -14774.061     -14855.008     -14855.008      313.27006      313.27006      36256.908      36256.908     -2446.9399     -2446.9399    
Loop time of 23.9816 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.603 ns/day, 6.662 hours/ns, 41.699 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.902     | 23.902     | 23.902     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01244    | 0.01244    | 0.01244    |   0.0 |  0.05
Output  | 3.0898e-05 | 3.0898e-05 | 3.0898e-05 |   0.0 |  0.00
Modify  | 0.062391   | 0.062391   | 0.062391   |   0.0 |  0.26
Other   |            | 0.00505    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121002 ave      121002 max      121002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121002
Ave neighs/atom = 60.501
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.438290075615, Press = -0.810271471229712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -14774.061     -14774.061     -14855.008     -14855.008      313.27006      313.27006      36256.908      36256.908     -2446.9399     -2446.9399    
     31000  -14779.97      -14779.97      -14859.734     -14859.734      308.69557      308.69557      36251.158      36251.158     -2646.3108     -2646.3108    
Loop time of 24.1179 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.582 ns/day, 6.699 hours/ns, 41.463 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.037     | 24.037     | 24.037     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012629   | 0.012629   | 0.012629   |   0.0 |  0.05
Output  | 2.17e-05   | 2.17e-05   | 2.17e-05   |   0.0 |  0.00
Modify  | 0.062908   | 0.062908   | 0.062908   |   0.0 |  0.26
Other   |            | 0.005075   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3329 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120816 ave      120816 max      120816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120816
Ave neighs/atom = 60.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.365187906938, Press = 1.89427844618165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -14779.97      -14779.97      -14859.734     -14859.734      308.69557      308.69557      36251.158      36251.158     -2646.3108     -2646.3108    
     32000  -14773.526     -14773.526     -14856.983     -14856.983      322.98572      322.98572      36209.805      36209.805     -60.198763     -60.198763    
Loop time of 24.195 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.571 ns/day, 6.721 hours/ns, 41.331 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.114     | 24.114     | 24.114     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012678   | 0.012678   | 0.012678   |   0.0 |  0.05
Output  | 3.0036e-05 | 3.0036e-05 | 3.0036e-05 |   0.0 |  0.00
Modify  | 0.063163   | 0.063163   | 0.063163   |   0.0 |  0.26
Other   |            | 0.005118   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3333 ave        3333 max        3333 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120826 ave      120826 max      120826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120826
Ave neighs/atom = 60.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.32782015392, Press = 1.94753054577539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -14773.526     -14773.526     -14856.983     -14856.983      322.98572      322.98572      36209.805      36209.805     -60.198763     -60.198763    
     33000  -14777.701     -14777.701     -14859.331     -14859.331      315.91467      315.91467      36181.63       36181.63       1085.1866      1085.1866    
Loop time of 24.3031 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.555 ns/day, 6.751 hours/ns, 41.147 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    | 24.222     | 24.222     | 24.222     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012789   | 0.012789   | 0.012789   |   0.0 |  0.05
Output  | 2.1911e-05 | 2.1911e-05 | 2.1911e-05 |   0.0 |  0.00
Modify  | 0.063057   | 0.063057   | 0.063057   |   0.0 |  0.26
Other   |            | 0.005124   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3387 ave        3387 max        3387 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121000 ave      121000 max      121000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121000
Ave neighs/atom = 60.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400308639026, Press = 1.04968105005123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -14777.701     -14777.701     -14859.331     -14859.331      315.91467      315.91467      36181.63       36181.63       1085.1866      1085.1866    
     34000  -14774.454     -14774.454     -14854.021     -14854.021      307.93399      307.93399      36191.874      36191.874      1060.9502      1060.9502    
Loop time of 24.1677 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.575 ns/day, 6.713 hours/ns, 41.377 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    | 24.087     | 24.087     | 24.087     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012935   | 0.012935   | 0.012935   |   0.0 |  0.05
Output  | 2.157e-05  | 2.157e-05  | 2.157e-05  |   0.0 |  0.00
Modify  | 0.062866   | 0.062866   | 0.062866   |   0.0 |  0.26
Other   |            | 0.005126   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3420 ave        3420 max        3420 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121148 ave      121148 max      121148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121148
Ave neighs/atom = 60.574
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.449679982098, Press = 0.204579379468818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -14774.454     -14774.454     -14854.021     -14854.021      307.93399      307.93399      36191.874      36191.874      1060.9502      1060.9502    
     35000  -14779.233     -14779.233     -14858.96      -14858.96       308.55106      308.55106      36201.734      36201.734      57.268446      57.268446    
Loop time of 24.0916 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.586 ns/day, 6.692 hours/ns, 41.508 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    | 24.011     | 24.011     | 24.011     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012552   | 0.012552   | 0.012552   |   0.0 |  0.05
Output  | 3.0086e-05 | 3.0086e-05 | 3.0086e-05 |   0.0 |  0.00
Modify  | 0.0626     | 0.0626     | 0.0626     |   0.0 |  0.26
Other   |            | 0.005073   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3357 ave        3357 max        3357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121154 ave      121154 max      121154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121154
Ave neighs/atom = 60.577
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.374133299678, Press = -0.828329001827494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -14779.233     -14779.233     -14858.96      -14858.96       308.55106      308.55106      36201.734      36201.734      57.268446      57.268446    
     36000  -14774.029     -14774.029     -14857.153     -14857.153      321.7002       321.7002       36263.478      36263.478     -2993.2185     -2993.2185    
Loop time of 24.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.591 ns/day, 6.684 hours/ns, 41.559 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    | 23.982     | 23.982     | 23.982     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012678   | 0.012678   | 0.012678   |   0.0 |  0.05
Output  | 2.165e-05  | 2.165e-05  | 2.165e-05  |   0.0 |  0.00
Modify  | 0.062623   | 0.062623   | 0.062623   |   0.0 |  0.26
Other   |            | 0.005092   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3386 ave        3386 max        3386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121012 ave      121012 max      121012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121012
Ave neighs/atom = 60.506
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.350303891993, Press = -0.607504170823775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -14774.029     -14774.029     -14857.153     -14857.153      321.7002       321.7002       36263.478      36263.478     -2993.2185     -2993.2185    
     37000  -14776.358     -14776.358     -14855.719     -14855.719      307.13496      307.13496      36251.432      36251.432     -2336.8276     -2336.8276    
Loop time of 24.0753 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.589 ns/day, 6.688 hours/ns, 41.536 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    | 23.995     | 23.995     | 23.995     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01251    | 0.01251    | 0.01251    |   0.0 |  0.05
Output  | 2.9205e-05 | 2.9205e-05 | 2.9205e-05 |   0.0 |  0.00
Modify  | 0.062878   | 0.062878   | 0.062878   |   0.0 |  0.26
Other   |            | 0.005065   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3303 ave        3303 max        3303 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120810 ave      120810 max      120810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120810
Ave neighs/atom = 60.405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.343373321373, Press = 1.61286339574636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -14776.358     -14776.358     -14855.719     -14855.719      307.13496      307.13496      36251.432      36251.432     -2336.8276     -2336.8276    
     38000  -14775.641     -14775.641     -14855.173     -14855.173      307.79645      307.79645      36201.601      36201.601      406.61175      406.61175    
Loop time of 24.1011 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.585 ns/day, 6.695 hours/ns, 41.492 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    | 24.021     | 24.021     | 24.021     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012562   | 0.012562   | 0.012562   |   0.0 |  0.05
Output  | 2.6549e-05 | 2.6549e-05 | 2.6549e-05 |   0.0 |  0.00
Modify  | 0.062555   | 0.062555   | 0.062555   |   0.0 |  0.26
Other   |            | 0.005084   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3334 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120966 ave      120966 max      120966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120966
Ave neighs/atom = 60.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425984269741, Press = 1.61765515120732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -14775.641     -14775.641     -14855.173     -14855.173      307.79645      307.79645      36201.601      36201.601      406.61175      406.61175    
     39000  -14774.099     -14774.099     -14857.064     -14857.064      321.08639      321.08639      36191.708      36191.708      757.06124      757.06124    
Loop time of 24.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.570 ns/day, 6.722 hours/ns, 41.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    | 24.118     | 24.118     | 24.118     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012946   | 0.012946   | 0.012946   |   0.0 |  0.05
Output  | 2.15e-05   | 2.15e-05   | 2.15e-05   |   0.0 |  0.00
Modify  | 0.063107   | 0.063107   | 0.063107   |   0.0 |  0.26
Other   |            | 0.005141   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3411 ave        3411 max        3411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120992 ave      120992 max      120992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120992
Ave neighs/atom = 60.496
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.44503415603, Press = 0.798411634100672
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -14774.099     -14774.099     -14857.064     -14857.064      321.08639      321.08639      36191.708      36191.708      757.06124      757.06124    
     40000  -14778.224     -14778.224     -14860.46      -14860.46       318.26322      318.26322      36175.98       36175.98       1332.7878      1332.7878    
Loop time of 24.1813 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.573 ns/day, 6.717 hours/ns, 41.354 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    | 24.1       | 24.1       | 24.1       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012759   | 0.012759   | 0.012759   |   0.0 |  0.05
Output  | 3.0577e-05 | 3.0577e-05 | 3.0577e-05 |   0.0 |  0.00
Modify  | 0.062925   | 0.062925   | 0.062925   |   0.0 |  0.26
Other   |            | 0.005131   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3387 ave        3387 max        3387 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121118 ave      121118 max      121118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121118
Ave neighs/atom = 60.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456594233478, Press = 0.151735452409081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -14778.224     -14778.224     -14860.46      -14860.46       318.26322      318.26322      36175.98       36175.98       1332.7878      1332.7878    
     41000  -14776.487     -14776.487     -14856.582     -14856.582      309.97538      309.97538      36207.814      36207.814     -79.393941     -79.393941    
Loop time of 24.2139 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.568 ns/day, 6.726 hours/ns, 41.299 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    | 24.133     | 24.133     | 24.133     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012822   | 0.012822   | 0.012822   |   0.0 |  0.05
Output  | 2.1571e-05 | 2.1571e-05 | 2.1571e-05 |   0.0 |  0.00
Modify  | 0.063007   | 0.063007   | 0.063007   |   0.0 |  0.26
Other   |            | 0.005134   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3401 ave        3401 max        3401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121080 ave      121080 max      121080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121080
Ave neighs/atom = 60.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.437758057029, Press = -0.737874725313711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -14776.487     -14776.487     -14856.582     -14856.582      309.97538      309.97538      36207.814      36207.814     -79.393941     -79.393941    
     42000  -14777.041     -14777.041     -14854.842     -14854.842      301.09763      301.09763      36253.938      36253.938     -2400.685      -2400.685     
Loop time of 24.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.580 ns/day, 6.704 hours/ns, 41.434 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.054     | 24.054     | 24.054     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012775   | 0.012775   | 0.012775   |   0.0 |  0.05
Output  | 3.0508e-05 | 3.0508e-05 | 3.0508e-05 |   0.0 |  0.00
Modify  | 0.062929   | 0.062929   | 0.062929   |   0.0 |  0.26
Other   |            | 0.005131   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3363 ave        3363 max        3363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121048 ave      121048 max      121048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121048
Ave neighs/atom = 60.524
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.350200676777, Press = -0.481327625778356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -14777.041     -14777.041     -14854.842     -14854.842      301.09763      301.09763      36253.938      36253.938     -2400.685      -2400.685     
     43000  -14778.183     -14778.183     -14857.637     -14857.637      307.4935       307.4935       36292.381      36292.381     -4669.3543     -4669.3543    
Loop time of 24.1669 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.575 ns/day, 6.713 hours/ns, 41.379 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    | 24.086     | 24.086     | 24.086     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012497   | 0.012497   | 0.012497   |   0.0 |  0.05
Output  | 2.184e-05  | 2.184e-05  | 2.184e-05  |   0.0 |  0.00
Modify  | 0.06315    | 0.06315    | 0.06315    |   0.0 |  0.26
Other   |            | 0.005099   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3290 ave        3290 max        3290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120862 ave      120862 max      120862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120862
Ave neighs/atom = 60.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.326836444653, Press = 2.38659496946227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -14778.183     -14778.183     -14857.637     -14857.637      307.4935       307.4935       36292.381      36292.381     -4669.3543     -4669.3543    
     44000  -14776.066     -14776.066     -14857.677     -14857.677      315.84234      315.84234      36193.039      36193.039      676.60779      676.60779    
Loop time of 24.2131 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.568 ns/day, 6.726 hours/ns, 41.300 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    | 24.132     | 24.132     | 24.132     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012636   | 0.012636   | 0.012636   |   0.0 |  0.05
Output  | 2.152e-05  | 2.152e-05  | 2.152e-05  |   0.0 |  0.00
Modify  | 0.063055   | 0.063055   | 0.063055   |   0.0 |  0.26
Other   |            | 0.005126   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3325 ave        3325 max        3325 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120652 ave      120652 max      120652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120652
Ave neighs/atom = 60.326
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.286992396625, Press = 1.84564164666061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -14776.066     -14776.066     -14857.677     -14857.677      315.84234      315.84234      36193.039      36193.039      676.60779      676.60779    
     45000  -14778.19      -14778.19      -14858.901     -14858.901      312.35857      312.35857      36183.742      36183.742      1053.9512      1053.9512    
Loop time of 24.3446 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.549 ns/day, 6.762 hours/ns, 41.077 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    | 24.263     | 24.263     | 24.263     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012846   | 0.012846   | 0.012846   |   0.0 |  0.05
Output  | 3.0538e-05 | 3.0538e-05 | 3.0538e-05 |   0.0 |  0.00
Modify  | 0.063292   | 0.063292   | 0.063292   |   0.0 |  0.26
Other   |            | 0.005243   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3395 ave        3395 max        3395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121042 ave      121042 max      121042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121042
Ave neighs/atom = 60.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.310196838184, Press = 0.941130661629813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -14778.19      -14778.19      -14858.901     -14858.901      312.35857      312.35857      36183.742      36183.742      1053.9512      1053.9512    
     46000  -14776.527     -14776.527     -14857.219     -14857.219      312.28565      312.28565      36179.749      36179.749      1426.5756      1426.5756    
Loop time of 24.2573 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.562 ns/day, 6.738 hours/ns, 41.225 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    | 24.176     | 24.176     | 24.176     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012821   | 0.012821   | 0.012821   |   0.0 |  0.05
Output  | 2.8163e-05 | 2.8163e-05 | 2.8163e-05 |   0.0 |  0.00
Modify  | 0.063387   | 0.063387   | 0.063387   |   0.0 |  0.26
Other   |            | 0.005174   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3386 ave        3386 max        3386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121016 ave      121016 max      121016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121016
Ave neighs/atom = 60.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.303927602791, Press = 0.250850732002871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -14776.527     -14776.527     -14857.219     -14857.219      312.28565      312.28565      36179.749      36179.749      1426.5756      1426.5756    
     47000  -14775.51      -14775.51      -14857.361     -14857.361      316.77207      316.77207      36207.281      36207.281      21.227339      21.227339    
Loop time of 24.3231 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.552 ns/day, 6.756 hours/ns, 41.113 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    | 24.242     | 24.242     | 24.242     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012919   | 0.012919   | 0.012919   |   0.0 |  0.05
Output  | 2.9555e-05 | 2.9555e-05 | 2.9555e-05 |   0.0 |  0.00
Modify  | 0.063485   | 0.063485   | 0.063485   |   0.0 |  0.26
Other   |            | 0.005157   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3395 ave        3395 max        3395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121068 ave      121068 max      121068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121068
Ave neighs/atom = 60.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.343681724458, Press = -0.355474325539826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -14775.51      -14775.51      -14857.361     -14857.361      316.77207      316.77207      36207.281      36207.281      21.227339      21.227339    
     48000  -14776.579     -14776.579     -14857.504     -14857.504      313.19075      313.19075      36250.42       36250.42      -2344.6127     -2344.6127    
Loop time of 24.2864 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.558 ns/day, 6.746 hours/ns, 41.175 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    | 24.205     | 24.205     | 24.205     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012689   | 0.012689   | 0.012689   |   0.0 |  0.05
Output  | 2.149e-05  | 2.149e-05  | 2.149e-05  |   0.0 |  0.00
Modify  | 0.063375   | 0.063375   | 0.063375   |   0.0 |  0.26
Other   |            | 0.005126   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3327 ave        3327 max        3327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121022 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.351116019711, Press = -0.282327311847074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -14776.579     -14776.579     -14857.504     -14857.504      313.19075      313.19075      36250.42       36250.42      -2344.6127     -2344.6127    
     49000  -14774.709     -14774.709     -14855.805     -14855.805      313.85256      313.85256      36267.396      36267.396     -3133.3549     -3133.3549    
Loop time of 24.2456 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.564 ns/day, 6.735 hours/ns, 41.245 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    | 24.165     | 24.165     | 24.165     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012599   | 0.012599   | 0.012599   |   0.0 |  0.05
Output  | 2.134e-05  | 2.134e-05  | 2.134e-05  |   0.0 |  0.00
Modify  | 0.063326   | 0.063326   | 0.063326   |   0.0 |  0.26
Other   |            | 0.005102   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3311 ave        3311 max        3311 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120862 ave      120862 max      120862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120862
Ave neighs/atom = 60.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.350716887626, Press = 1.09049716610809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -14774.709     -14774.709     -14855.805     -14855.805      313.85256      313.85256      36267.396      36267.396     -3133.3549     -3133.3549    
     50000  -14780.242     -14780.242     -14860.003     -14860.003      308.68508      308.68508      36207.793      36207.793     -372.65271     -372.65271    
Loop time of 24.2032 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.570 ns/day, 6.723 hours/ns, 41.317 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    | 24.122     | 24.122     | 24.122     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012757   | 0.012757   | 0.012757   |   0.0 |  0.05
Output  | 3.0517e-05 | 3.0517e-05 | 3.0517e-05 |   0.0 |  0.00
Modify  | 0.063241   | 0.063241   | 0.063241   |   0.0 |  0.26
Other   |            | 0.005161   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3350 ave        3350 max        3350 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120802 ave      120802 max      120802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120802
Ave neighs/atom = 60.401
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.302029881435, Press = 1.25324526912659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -14780.242     -14780.242     -14860.003     -14860.003      308.68508      308.68508      36207.793      36207.793     -372.65271     -372.65271    
     51000  -14774.648     -14774.648     -14856.171     -14856.171      315.49891      315.49891      36187.951      36187.951      1138.118       1138.118     
Loop time of 24.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.566 ns/day, 6.730 hours/ns, 41.276 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    | 24.146     | 24.146     | 24.146     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012632   | 0.012632   | 0.012632   |   0.0 |  0.05
Output  | 2.157e-05  | 2.157e-05  | 2.157e-05  |   0.0 |  0.00
Modify  | 0.063083   | 0.063083   | 0.063083   |   0.0 |  0.26
Other   |            | 0.005085   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3331 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121010 ave      121010 max      121010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121010
Ave neighs/atom = 60.505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.273575814021, Press = 0.649746292739461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -14774.648     -14774.648     -14856.171     -14856.171      315.49891      315.49891      36187.951      36187.951      1138.118       1138.118     
     52000  -14777.534     -14777.534     -14856.994     -14856.994      307.51868      307.51868      36199.094      36199.094      346.06447      346.06447    
Loop time of 24.2225 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.567 ns/day, 6.728 hours/ns, 41.284 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    | 24.141     | 24.141     | 24.141     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012812   | 0.012812   | 0.012812   |   0.0 |  0.05
Output  | 2.8293e-05 | 2.8293e-05 | 2.8293e-05 |   0.0 |  0.00
Modify  | 0.063193   | 0.063193   | 0.063193   |   0.0 |  0.26
Other   |            | 0.005134   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3357 ave        3357 max        3357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121076 ave      121076 max      121076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0