# 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 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -14853.917     -14853.917     -14940         -14940          333.15         333.15         36016.89       36016.89       2552.9005      2552.9005    
      1000  -14765.449     -14765.449     -14857.768     -14857.768      357.28264      357.28264      36262.533      36262.533     -2681.6746     -2681.6746    
Loop time of 13.0122 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.640 ns/day, 3.614 hours/ns, 76.851 timesteps/s
99.0% 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.935     | 12.935     | 12.935     |   0.0 | 99.41
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.011184   | 0.011184   | 0.011184   |   0.0 |  0.09
Output  | 0.00014388 | 0.00014388 | 0.00014388 |   0.0 |  0.00
Modify  | 0.060292   | 0.060292   | 0.060292   |   0.0 |  0.46
Other   |            | 0.005049   |            |       |  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  -14765.449     -14765.449     -14857.768     -14857.768      357.28264      357.28264      36262.533      36262.533     -2681.6746     -2681.6746    
      2000  -14764.014     -14764.014     -14846.501     -14846.501      319.23258      319.23258      36206.218      36206.218      1109.4903      1109.4903    
Loop time of 23.9275 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.611 ns/day, 6.647 hours/ns, 41.793 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.85      | 23.85      | 23.85      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012392   | 0.012392   | 0.012392   |   0.0 |  0.05
Output  | 8.2265e-05 | 8.2265e-05 | 8.2265e-05 |   0.0 |  0.00
Modify  | 0.059518   | 0.059518   | 0.059518   |   0.0 |  0.25
Other   |            | 0.005059   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3339 ave        3339 max        3339 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120834 ave      120834 max      120834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120834
Ave neighs/atom = 60.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14764.014     -14764.014     -14846.501     -14846.501      319.23258      319.23258      36206.218      36206.218      1109.4903      1109.4903    
      3000  -14767.699     -14767.699     -14853.968     -14853.968      333.87071      333.87071      36212.187      36212.187      87.687827      87.687827    
Loop time of 23.9686 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.605 ns/day, 6.658 hours/ns, 41.721 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.892     | 23.892     | 23.892     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012407   | 0.012407   | 0.012407   |   0.0 |  0.05
Output  | 7.4419e-05 | 7.4419e-05 | 7.4419e-05 |   0.0 |  0.00
Modify  | 0.059425   | 0.059425   | 0.059425   |   0.0 |  0.25
Other   |            | 0.005071   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3356 ave        3356 max        3356 min
Histogram: 1 0 0 0 0 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 = 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  -14767.699     -14767.699     -14853.968     -14853.968      333.87071      333.87071      36212.187      36212.187      87.687827      87.687827    
      4000  -14763.233     -14763.233     -14850.115     -14850.115      336.24357      336.24357      36251.462      36251.462     -1517.4675     -1517.4675    
Loop time of 24.0111 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.598 ns/day, 6.670 hours/ns, 41.647 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.934     | 23.934     | 23.934     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012445   | 0.012445   | 0.012445   |   0.0 |  0.05
Output  | 3.7881e-05 | 3.7881e-05 | 3.7881e-05 |   0.0 |  0.00
Modify  | 0.059322   | 0.059322   | 0.059322   |   0.0 |  0.25
Other   |            | 0.005043   |            |       |  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:       121018 ave      121018 max      121018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121018
Ave neighs/atom = 60.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14763.233     -14763.233     -14850.115     -14850.115      336.24357      336.24357      36251.462      36251.462     -1517.4675     -1517.4675    
      5000  -14767.444     -14767.444     -14852.686     -14852.686      329.89588      329.89588      36188.689      36188.689      1417.539       1417.539     
Loop time of 23.9044 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.614 ns/day, 6.640 hours/ns, 41.833 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.827     | 23.827     | 23.827     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012394   | 0.012394   | 0.012394   |   0.0 |  0.05
Output  | 2.8995e-05 | 2.8995e-05 | 2.8995e-05 |   0.0 |  0.00
Modify  | 0.059671   | 0.059671   | 0.059671   |   0.0 |  0.25
Other   |            | 0.005051   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3354 ave        3354 max        3354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120860 ave      120860 max      120860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120860
Ave neighs/atom = 60.43
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 328.119054334058, Press = -374.494233649321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.444     -14767.444     -14852.686     -14852.686      329.89588      329.89588      36188.689      36188.689      1417.539       1417.539     
      6000  -14764.41      -14764.41      -14849.582     -14849.582      329.62516      329.62516      36235.514      36235.514     -794.48712     -794.48712    
Loop time of 23.9058 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.614 ns/day, 6.641 hours/ns, 41.831 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.827     | 23.827     | 23.827     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012474   | 0.012474   | 0.012474   |   0.0 |  0.05
Output  | 2.9024e-05 | 2.9024e-05 | 2.9024e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.26
Other   |            | 0.005079   |            |       |  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:       121056 ave      121056 max      121056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121056
Ave neighs/atom = 60.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.644340662626, Press = -25.3893779779842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.41      -14764.41      -14849.582     -14849.582      329.62516      329.62516      36235.514      36235.514     -794.48712     -794.48712    
      7000  -14766.085     -14766.085     -14852.709     -14852.709      335.24594      335.24594      36222.805      36222.805     -274.34085     -274.34085    
Loop time of 23.8541 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.622 ns/day, 6.626 hours/ns, 41.922 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.775     | 23.775     | 23.775     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012521   | 0.012521   | 0.012521   |   0.0 |  0.05
Output  | 2.4175e-05 | 2.4175e-05 | 2.4175e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.26
Other   |            | 0.005012   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3343 ave        3343 max        3343 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120952 ave      120952 max      120952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120952
Ave neighs/atom = 60.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.131635195815, Press = -11.8750846311685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14766.085     -14766.085     -14852.709     -14852.709      335.24594      335.24594      36222.805      36222.805     -274.34085     -274.34085    
      8000  -14767.531     -14767.531     -14853.667     -14853.667      333.35866      333.35866      36211.513      36211.513      205.56449      205.56449    
Loop time of 23.8859 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.617 ns/day, 6.635 hours/ns, 41.866 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.806     | 23.806     | 23.806     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012494   | 0.012494   | 0.012494   |   0.0 |  0.05
Output  | 3.2581e-05 | 3.2581e-05 | 3.2581e-05 |   0.0 |  0.00
Modify  | 0.062097   | 0.062097   | 0.062097   |   0.0 |  0.26
Other   |            | 0.005025   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3373 ave        3373 max        3373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120998 ave      120998 max      120998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120998
Ave neighs/atom = 60.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.351644970009, Press = -9.09629514747175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.531     -14767.531     -14853.667     -14853.667      333.35866      333.35866      36211.513      36211.513      205.56449      205.56449    
      9000  -14763.212     -14763.212     -14851.633     -14851.633      342.19612      342.19612      36229.343      36229.343     -558.7668      -558.7668     
Loop time of 23.9002 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.615 ns/day, 6.639 hours/ns, 41.841 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.821     | 23.821     | 23.821     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012827   | 0.012827   | 0.012827   |   0.0 |  0.05
Output  | 2.8383e-05 | 2.8383e-05 | 2.8383e-05 |   0.0 |  0.00
Modify  | 0.061757   | 0.061757   | 0.061757   |   0.0 |  0.26
Other   |            | 0.005005   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3441 ave        3441 max        3441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121100 ave      121100 max      121100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121100
Ave neighs/atom = 60.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.451149650094, Press = -9.7053842905711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.212     -14763.212     -14851.633     -14851.633      342.19612      342.19612      36229.343      36229.343     -558.7668      -558.7668     
     10000  -14764.143     -14764.143     -14852.664     -14852.664      342.58558      342.58558      36226.08       36226.08      -373.32031     -373.32031    
Loop time of 23.9759 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.604 ns/day, 6.660 hours/ns, 41.708 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.897     | 23.897     | 23.897     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012555   | 0.012555   | 0.012555   |   0.0 |  0.05
Output  | 2.2592e-05 | 2.2592e-05 | 2.2592e-05 |   0.0 |  0.00
Modify  | 0.061744   | 0.061744   | 0.061744   |   0.0 |  0.26
Other   |            | 0.004963   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3383 ave        3383 max        3383 min
Histogram: 1 0 0 0 0 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 = 331.976298243227, Press = -6.25219294501757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     10000  -14764.143     -14764.143     -14852.664     -14852.664      342.58558      342.58558      36226.08       36226.08      -373.32031     -373.32031    
     11000  -14768.543     -14768.543     -14854.529     -14854.529      332.77245      332.77245      36205.615      36205.615      463.3537       463.3537     
Loop time of 23.9934 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.601 ns/day, 6.665 hours/ns, 41.678 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.915     | 23.915     | 23.915     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012233   | 0.012233   | 0.012233   |   0.0 |  0.05
Output  | 2.1641e-05 | 2.1641e-05 | 2.1641e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.26
Other   |            | 0.004938   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3297 ave        3297 max        3297 min
Histogram: 1 0 0 0 0 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 = 332.519603276261, Press = -3.13479397120617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14768.543     -14768.543     -14854.529     -14854.529      332.77245      332.77245      36205.615      36205.615      463.3537       463.3537     
     12000  -14764.093     -14764.093     -14852.214     -14852.214      341.03489      341.03489      36231.301      36231.301     -694.54673     -694.54673    
Loop time of 23.9713 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.604 ns/day, 6.659 hours/ns, 41.717 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.892     | 23.892     | 23.892     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012437   | 0.012437   | 0.012437   |   0.0 |  0.05
Output  | 2.7923e-05 | 2.7923e-05 | 2.7923e-05 |   0.0 |  0.00
Modify  | 0.061763   | 0.061763   | 0.061763   |   0.0 |  0.26
Other   |            | 0.004962   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3332 ave        3332 max        3332 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120958 ave      120958 max      120958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120958
Ave neighs/atom = 60.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.340460190259, Press = -6.94744189706594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.093     -14764.093     -14852.214     -14852.214      341.03489      341.03489      36231.301      36231.301     -694.54673     -694.54673    
     13000  -14769.822     -14769.822     -14854.677     -14854.677      328.39591      328.39591      36214.392      36214.392     -10.953347     -10.953347    
Loop time of 23.8559 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.622 ns/day, 6.627 hours/ns, 41.918 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.777     | 23.777     | 23.777     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01249    | 0.01249    | 0.01249    |   0.0 |  0.05
Output  | 2.2111e-05 | 2.2111e-05 | 2.2111e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.26
Other   |            | 0.004953   |            |       |  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:       120920 ave      120920 max      120920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120920
Ave neighs/atom = 60.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.16114638848, Press = -1.35971495103527
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14769.822     -14769.822     -14854.677     -14854.677      328.39591      328.39591      36214.392      36214.392     -10.953347     -10.953347    
     14000  -14764.602     -14764.602     -14849.698     -14849.698      329.33227      329.33227      36209.879      36209.879      715.66245      715.66245    
Loop time of 23.8408 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.624 ns/day, 6.622 hours/ns, 41.945 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.761     | 23.761     | 23.761     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012552   | 0.012552   | 0.012552   |   0.0 |  0.05
Output  | 2.689e-05  | 2.689e-05  | 2.689e-05  |   0.0 |  0.00
Modify  | 0.061802   | 0.061802   | 0.061802   |   0.0 |  0.26
Other   |            | 0.005037   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3366 ave        3366 max        3366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120934 ave      120934 max      120934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120934
Ave neighs/atom = 60.467
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.156414827841, Press = -6.35972519978727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.602     -14764.602     -14849.698     -14849.698      329.33227      329.33227      36209.879      36209.879      715.66245      715.66245    
     15000  -14767.793     -14767.793     -14851.591     -14851.591      324.30714      324.30714      36254.301      36254.301     -1933.0595     -1933.0595    
Loop time of 23.9136 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.613 ns/day, 6.643 hours/ns, 41.817 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.834     | 23.834     | 23.834     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012425   | 0.012425   | 0.012425   |   0.0 |  0.05
Output  | 2.2011e-05 | 2.2011e-05 | 2.2011e-05 |   0.0 |  0.00
Modify  | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.26
Other   |            | 0.005026   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 min
Histogram: 1 0 0 0 0 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 = 332.203112312361, Press = -0.556456430984263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.793     -14767.793     -14851.591     -14851.591      324.30714      324.30714      36254.301      36254.301     -1933.0595     -1933.0595    
     16000  -14761.049     -14761.049     -14851.068     -14851.068      348.38232      348.38232      36165.177      36165.177      3013.3369      3013.3369    
Loop time of 23.8838 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.618 ns/day, 6.634 hours/ns, 41.869 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.805     | 23.805     | 23.805     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012476   | 0.012476   | 0.012476   |   0.0 |  0.05
Output  | 2.162e-05  | 2.162e-05  | 2.162e-05  |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.26
Other   |            | 0.004965   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120830 ave      120830 max      120830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120830
Ave neighs/atom = 60.415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.437267134857, Press = -3.40718155005533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14761.049     -14761.049     -14851.068     -14851.068      348.38232      348.38232      36165.177      36165.177      3013.3369      3013.3369    
     17000  -14767.546     -14767.546     -14853.112     -14853.112      331.14785      331.14785      36256.121      36256.121     -2088.0457     -2088.0457    
Loop time of 23.8885 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.617 ns/day, 6.636 hours/ns, 41.861 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.809     | 23.809     | 23.809     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012462   | 0.012462   | 0.012462   |   0.0 |  0.05
Output  | 2.7963e-05 | 2.7963e-05 | 2.7963e-05 |   0.0 |  0.00
Modify  | 0.061821   | 0.061821   | 0.061821   |   0.0 |  0.26
Other   |            | 0.004982   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121150 ave      121150 max      121150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121150
Ave neighs/atom = 60.575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.629789748149, Press = -4.03251343511605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.546     -14767.546     -14853.112     -14853.112      331.14785      331.14785      36256.121      36256.121     -2088.0457     -2088.0457    
     18000  -14766.531     -14766.531     -14850.493     -14850.493      324.93965      324.93965      36213.964      36213.964      402.77582      402.77582    
Loop time of 23.7652 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.636 ns/day, 6.601 hours/ns, 42.078 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.686     | 23.686     | 23.686     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012424   | 0.012424   | 0.012424   |   0.0 |  0.05
Output  | 2.1901e-05 | 2.1901e-05 | 2.1901e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.26
Other   |            | 0.004966   |            |       |  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:       120878 ave      120878 max      120878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120878
Ave neighs/atom = 60.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.759976673404, Press = -1.63282964111306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14766.531     -14766.531     -14850.493     -14850.493      324.93965      324.93965      36213.964      36213.964      402.77582      402.77582    
     19000  -14769.018     -14769.018     -14851.201     -14851.201      318.05671      318.05671      36212.998      36212.998      338.03229      338.03229    
Loop time of 23.7775 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.634 ns/day, 6.605 hours/ns, 42.057 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.698     | 23.698     | 23.698     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012395   | 0.012395   | 0.012395   |   0.0 |  0.05
Output  | 2.175e-05  | 2.175e-05  | 2.175e-05  |   0.0 |  0.00
Modify  | 0.061677   | 0.061677   | 0.061677   |   0.0 |  0.26
Other   |            | 0.004955   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121030 ave      121030 max      121030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121030
Ave neighs/atom = 60.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.61883538528, Press = -3.71536051386445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14769.018     -14769.018     -14851.201     -14851.201      318.05671      318.05671      36212.998      36212.998      338.03229      338.03229    
     20000  -14765.474     -14765.474     -14852.489     -14852.489      336.7571       336.7571       36232.726      36232.726     -747.69471     -747.69471    
Loop time of 23.8555 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.622 ns/day, 6.627 hours/ns, 41.919 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.776     | 23.776     | 23.776     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01259    | 0.01259    | 0.01259    |   0.0 |  0.05
Output  | 3.1209e-05 | 3.1209e-05 | 3.1209e-05 |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.26
Other   |            | 0.005016   |            |       |  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:       120952 ave      120952 max      120952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120952
Ave neighs/atom = 60.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.560294791924, Press = -1.23901465819967
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.474     -14765.474     -14852.489     -14852.489      336.7571       336.7571       36232.726      36232.726     -747.69471     -747.69471    
     21000  -14763.726     -14763.726     -14850.461     -14850.461      335.67605      335.67605      36181.738      36181.738      2175.7899      2175.7899    
Loop time of 23.8386 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.624 ns/day, 6.622 hours/ns, 41.949 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.759     | 23.759     | 23.759     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012532   | 0.012532   | 0.012532   |   0.0 |  0.05
Output  | 2.1801e-05 | 2.1801e-05 | 2.1801e-05 |   0.0 |  0.00
Modify  | 0.061635   | 0.061635   | 0.061635   |   0.0 |  0.26
Other   |            | 0.005068   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3388 ave        3388 max        3388 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120920 ave      120920 max      120920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120920
Ave neighs/atom = 60.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.452518778526, Press = -2.49289874091367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.726     -14763.726     -14850.461     -14850.461      335.67605      335.67605      36181.738      36181.738      2175.7899      2175.7899    
     22000  -14766.429     -14766.429     -14853.324     -14853.324      336.29304      336.29304      36272.945      36272.945     -2923.5309     -2923.5309    
Loop time of 23.8642 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.620 ns/day, 6.629 hours/ns, 41.904 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.785     | 23.785     | 23.785     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012743   | 0.012743   | 0.012743   |   0.0 |  0.05
Output  | 3.8402e-05 | 3.8402e-05 | 3.8402e-05 |   0.0 |  0.00
Modify  | 0.061747   | 0.061747   | 0.061747   |   0.0 |  0.26
Other   |            | 0.005093   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3409 ave        3409 max        3409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121072 ave      121072 max      121072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121072
Ave neighs/atom = 60.536
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.522257750236, Press = -3.59998082287241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     22000  -14766.429     -14766.429     -14853.324     -14853.324      336.29304      336.29304      36272.945      36272.945     -2923.5309     -2923.5309    
     23000  -14763.085     -14763.085     -14851.414     -14851.414      341.84533      341.84533      36195.604      36195.604      1381.2256      1381.2256    
Loop time of 23.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.635 ns/day, 6.603 hours/ns, 42.070 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.691     | 23.691     | 23.691     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012308   | 0.012308   | 0.012308   |   0.0 |  0.05
Output  | 2.2052e-05 | 2.2052e-05 | 2.2052e-05 |   0.0 |  0.00
Modify  | 0.061744   | 0.061744   | 0.061744   |   0.0 |  0.26
Other   |            | 0.005056   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3316 ave        3316 max        3316 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120784 ave      120784 max      120784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120784
Ave neighs/atom = 60.392
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.602730480224, Press = 0.779079721566285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.085     -14763.085     -14851.414     -14851.414      341.84533      341.84533      36195.604      36195.604      1381.2256      1381.2256    
     24000  -14765.809     -14765.809     -14850.648     -14850.648      328.33463      328.33463      36220.089      36220.089      48.67626       48.67626     
Loop time of 23.8354 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.625 ns/day, 6.621 hours/ns, 41.954 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.756     | 23.756     | 23.756     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012293   | 0.012293   | 0.012293   |   0.0 |  0.05
Output  | 2.153e-05  | 2.153e-05  | 2.153e-05  |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.26
Other   |            | 0.005019   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3322 ave        3322 max        3322 min
Histogram: 1 0 0 0 0 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 = 332.566138486676, Press = -3.45329467129845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.809     -14765.809     -14850.648     -14850.648      328.33463      328.33463      36220.089      36220.089      48.67626       48.67626     
     25000  -14770.195     -14770.195     -14855.191     -14855.191      328.94596      328.94596      36220.754      36220.754     -452.15025     -452.15025    
Loop time of 23.8374 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.625 ns/day, 6.622 hours/ns, 41.951 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.758     | 23.758     | 23.758     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012322   | 0.012322   | 0.012322   |   0.0 |  0.05
Output  | 2.9285e-05 | 2.9285e-05 | 2.9285e-05 |   0.0 |  0.00
Modify  | 0.06179    | 0.06179    | 0.06179    |   0.0 |  0.26
Other   |            | 0.004933   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3291 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120976 ave      120976 max      120976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120976
Ave neighs/atom = 60.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.540248375229, Press = -1.21148268653514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14770.195     -14770.195     -14855.191     -14855.191      328.94596      328.94596      36220.754      36220.754     -452.15025     -452.15025    
     26000  -14763.597     -14763.597     -14850.673     -14850.673      336.99313      336.99313      36220.501      36220.501      80.450501      80.450501    
Loop time of 23.8682 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.620 ns/day, 6.630 hours/ns, 41.897 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.789     | 23.789     | 23.789     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012607   | 0.012607   | 0.012607   |   0.0 |  0.05
Output  | 2.161e-05  | 2.161e-05  | 2.161e-05  |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.26
Other   |            | 0.00496    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3383 ave        3383 max        3383 min
Histogram: 1 0 0 0 0 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 = 332.460094937602, Press = -2.11115721350345
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.597     -14763.597     -14850.673     -14850.673      336.99313      336.99313      36220.501      36220.501      80.450501      80.450501    
     27000  -14765.063     -14765.063     -14850.714     -14850.714      331.47792      331.47792      36231.589      36231.589     -518.23051     -518.23051    
Loop time of 23.8629 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.621 ns/day, 6.629 hours/ns, 41.906 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.783     | 23.783     | 23.783     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012692   | 0.012692   | 0.012692   |   0.0 |  0.05
Output  | 2.8033e-05 | 2.8033e-05 | 2.8033e-05 |   0.0 |  0.00
Modify  | 0.061768   | 0.061768   | 0.061768   |   0.0 |  0.26
Other   |            | 0.005046   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3393 ave        3393 max        3393 min
Histogram: 1 0 0 0 0 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 = 332.471326629573, Press = -1.12846858178886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.063     -14765.063     -14850.714     -14850.714      331.47792      331.47792      36231.589      36231.589     -518.23051     -518.23051    
     28000  -14766.156     -14766.156     -14853.624     -14853.624      338.51069      338.51069      36186.518      36186.518      1585.1413      1585.1413    
Loop time of 23.9255 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.611 ns/day, 6.646 hours/ns, 41.796 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.846     | 23.846     | 23.846     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012605   | 0.012605   | 0.012605   |   0.0 |  0.05
Output  | 2.183e-05  | 2.183e-05  | 2.183e-05  |   0.0 |  0.00
Modify  | 0.061659   | 0.061659   | 0.061659   |   0.0 |  0.26
Other   |            | 0.005002   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3374 ave        3374 max        3374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120946 ave      120946 max      120946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120946
Ave neighs/atom = 60.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.635754066129, Press = -2.19436015518221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14766.156     -14766.156     -14853.624     -14853.624      338.51069      338.51069      36186.518      36186.518      1585.1413      1585.1413    
     29000  -14762.605     -14762.605     -14852.197     -14852.197      346.72768      346.72768      36265.702      36265.702     -2434.7832     -2434.7832    
Loop time of 23.9501 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.608 ns/day, 6.653 hours/ns, 41.753 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.871     | 23.871     | 23.871     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01281    | 0.01281    | 0.01281    |   0.0 |  0.05
Output  | 2.153e-05  | 2.153e-05  | 2.153e-05  |   0.0 |  0.00
Modify  | 0.061755   | 0.061755   | 0.061755   |   0.0 |  0.26
Other   |            | 0.004972   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3419 ave        3419 max        3419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121146 ave      121146 max      121146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121146
Ave neighs/atom = 60.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.741057071103, Press = -2.36131711937983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14762.605     -14762.605     -14852.197     -14852.197      346.72768      346.72768      36265.702      36265.702     -2434.7832     -2434.7832    
     30000  -14765.893     -14765.893     -14851.719     -14851.719      332.15669      332.15669      36189.192      36189.192      1630.0086      1630.0086    
Loop time of 23.8896 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.617 ns/day, 6.636 hours/ns, 41.859 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.81      | 23.81      | 23.81      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012365   | 0.012365   | 0.012365   |   0.0 |  0.05
Output  | 2.8984e-05 | 2.8984e-05 | 2.8984e-05 |   0.0 |  0.00
Modify  | 0.061778   | 0.061778   | 0.061778   |   0.0 |  0.26
Other   |            | 0.004946   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3321 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120776 ave      120776 max      120776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120776
Ave neighs/atom = 60.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.794737565336, Press = 0.435377627143807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.893     -14765.893     -14851.719     -14851.719      332.15669      332.15669      36189.192      36189.192      1630.0086      1630.0086    
     31000  -14765.981     -14765.981     -14850.519     -14850.519      327.16982      327.16982      36228.192      36228.192     -346.28716     -346.28716    
Loop time of 23.8371 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.625 ns/day, 6.621 hours/ns, 41.951 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.758     | 23.758     | 23.758     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012353   | 0.012353   | 0.012353   |   0.0 |  0.05
Output  | 2.1661e-05 | 2.1661e-05 | 2.1661e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.26
Other   |            | 0.004932   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3332 ave        3332 max        3332 min
Histogram: 1 0 0 0 0 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 = 332.796281378115, Press = -3.30105778967242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.981     -14765.981     -14850.519     -14850.519      327.16982      327.16982      36228.192      36228.192     -346.28716     -346.28716    
     32000  -14763.806     -14763.806     -14849.937     -14849.937      333.339        333.339        36236.443      36236.443     -720.09436     -720.09436    
Loop time of 23.8981 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.615 ns/day, 6.638 hours/ns, 41.844 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.819     | 23.819     | 23.819     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012528   | 0.012528   | 0.012528   |   0.0 |  0.05
Output  | 2.9165e-05 | 2.9165e-05 | 2.9165e-05 |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.26
Other   |            | 0.004964   |            |       |  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:       121058 ave      121058 max      121058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121058
Ave neighs/atom = 60.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.796474209781, Press = -0.70381509718872
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.806     -14763.806     -14849.937     -14849.937      333.339        333.339        36236.443      36236.443     -720.09436     -720.09436    
     33000  -14767.89      -14767.89      -14853.797     -14853.797      332.46957      332.46957      36205.308      36205.308      587.43004      587.43004    
Loop time of 23.9015 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.615 ns/day, 6.639 hours/ns, 41.838 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.822     | 23.822     | 23.822     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012666   | 0.012666   | 0.012666   |   0.0 |  0.05
Output  | 2.2312e-05 | 2.2312e-05 | 2.2312e-05 |   0.0 |  0.00
Modify  | 0.061832   | 0.061832   | 0.061832   |   0.0 |  0.26
Other   |            | 0.004995   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3389 ave        3389 max        3389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120988 ave      120988 max      120988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120988
Ave neighs/atom = 60.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.723298035286, Press = -1.86452561289367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.89      -14767.89      -14853.797     -14853.797      332.46957      332.46957      36205.308      36205.308      587.43004      587.43004    
     34000  -14763.024     -14763.024     -14851.319     -14851.319      341.70958      341.70958      36244.633      36244.633     -1212.5092     -1212.5092    
Loop time of 23.9142 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.613 ns/day, 6.643 hours/ns, 41.816 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.835     | 23.835     | 23.835     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012665   | 0.012665   | 0.012665   |   0.0 |  0.05
Output  | 2.1931e-05 | 2.1931e-05 | 2.1931e-05 |   0.0 |  0.00
Modify  | 0.061793   | 0.061793   | 0.061793   |   0.0 |  0.26
Other   |            | 0.005017   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3371 ave        3371 max        3371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121052 ave      121052 max      121052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121052
Ave neighs/atom = 60.526
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.731424786259, Press = -1.3516609647889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14763.024     -14763.024     -14851.319     -14851.319      341.70958      341.70958      36244.633      36244.633     -1212.5092     -1212.5092    
     35000  -14767.101     -14767.101     -14852.827     -14852.827      331.76898      331.76898      36184.867      36184.867      1641.3755      1641.3755    
Loop time of 23.8819 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.618 ns/day, 6.634 hours/ns, 41.873 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.803     | 23.803     | 23.803     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012588   | 0.012588   | 0.012588   |   0.0 |  0.05
Output  | 3.0317e-05 | 3.0317e-05 | 3.0317e-05 |   0.0 |  0.00
Modify  | 0.061751   | 0.061751   | 0.061751   |   0.0 |  0.26
Other   |            | 0.005006   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3372 ave        3372 max        3372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120950 ave      120950 max      120950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120950
Ave neighs/atom = 60.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.800406502028, Press = -0.71077473725307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.101     -14767.101     -14852.827     -14852.827      331.76898      331.76898      36184.867      36184.867      1641.3755      1641.3755    
     36000  -14766.27      -14766.27      -14853.897     -14853.897      339.1247       339.1247       36268.728      36268.728     -2822.1807     -2822.1807    
Loop time of 23.9369 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.609 ns/day, 6.649 hours/ns, 41.776 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.858     | 23.858     | 23.858     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012359   | 0.012359   | 0.012359   |   0.0 |  0.05
Output  | 2.3484e-05 | 2.3484e-05 | 2.3484e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.26
Other   |            | 0.004944   |            |       |  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:       121110 ave      121110 max      121110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121110
Ave neighs/atom = 60.555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.85650470024, Press = -3.86690992953362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14766.27      -14766.27      -14853.897     -14853.897      339.1247       339.1247       36268.728      36268.728     -2822.1807     -2822.1807    
     37000  -14769.354     -14769.354     -14855.252     -14855.252      332.43448      332.43448      36218.392      36218.392     -297.12787     -297.12787    
Loop time of 23.8788 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.618 ns/day, 6.633 hours/ns, 41.878 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.799     | 23.799     | 23.799     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012425   | 0.012425   | 0.012425   |   0.0 |  0.05
Output  | 2.8483e-05 | 2.8483e-05 | 2.8483e-05 |   0.0 |  0.00
Modify  | 0.061884   | 0.061884   | 0.061884   |   0.0 |  0.26
Other   |            | 0.00498    |            |       |  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:       120852 ave      120852 max      120852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120852
Ave neighs/atom = 60.426
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.792150882049, Press = 0.401444342578518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14769.354     -14769.354     -14855.252     -14855.252      332.43448      332.43448      36218.392      36218.392     -297.12787     -297.12787    
     38000  -14765.902     -14765.902     -14852.741     -14852.741      336.07359      336.07359      36199.862      36199.862      991.98627      991.98627    
Loop time of 23.8598 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.621 ns/day, 6.628 hours/ns, 41.912 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.781     | 23.781     | 23.781     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012434   | 0.012434   | 0.012434   |   0.0 |  0.05
Output  | 2.1981e-05 | 2.1981e-05 | 2.1981e-05 |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.26
Other   |            | 0.005043   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120990 ave      120990 max      120990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120990
Ave neighs/atom = 60.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.764653369373, Press = -2.21761378740103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.902     -14765.902     -14852.741     -14852.741      336.07359      336.07359      36199.862      36199.862      991.98627      991.98627    
     39000  -14766.635     -14766.635     -14851.717     -14851.717      329.27897      329.27897      36243.519      36243.519     -1254.673      -1254.673     
Loop time of 23.8733 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.619 ns/day, 6.631 hours/ns, 41.888 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.794     | 23.794     | 23.794     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012619   | 0.012619   | 0.012619   |   0.0 |  0.05
Output  | 2.147e-05  | 2.147e-05  | 2.147e-05  |   0.0 |  0.00
Modify  | 0.061698   | 0.061698   | 0.061698   |   0.0 |  0.26
Other   |            | 0.00508    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3384 ave        3384 max        3384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121026 ave      121026 max      121026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121026
Ave neighs/atom = 60.513
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.712090103993, Press = -0.478836258639532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14766.635     -14766.635     -14851.717     -14851.717      329.27897      329.27897      36243.519      36243.519     -1254.673      -1254.673     
     40000  -14765.486     -14765.486     -14854.075     -14854.075      342.85133      342.85133      36187.291      36187.291      1604.8235      1604.8235    
Loop time of 23.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.622 ns/day, 6.627 hours/ns, 41.918 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.777     | 23.777     | 23.777     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012558   | 0.012558   | 0.012558   |   0.0 |  0.05
Output  | 3.0427e-05 | 3.0427e-05 | 3.0427e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.26
Other   |            | 0.00501    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3372 ave        3372 max        3372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120920 ave      120920 max      120920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120920
Ave neighs/atom = 60.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.734994171481, Press = -0.826315993359545
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14765.486     -14765.486     -14854.075     -14854.075      342.85133      342.85133      36187.291      36187.291      1604.8235      1604.8235    
     41000  -14767.795     -14767.795     -14850.547     -14850.547      320.26167      320.26167      36255.092      36255.092     -1916.73       -1916.73      
Loop time of 23.8032 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.630 ns/day, 6.612 hours/ns, 42.011 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.724     | 23.724     | 23.724     |   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.171e-05  | 2.171e-05  | 2.171e-05  |   0.0 |  0.00
Modify  | 0.061635   | 0.061635   | 0.061635   |   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:           3435 ave        3435 max        3435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121196 ave      121196 max      121196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121196
Ave neighs/atom = 60.598
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.646278681962, Press = -2.29576804772122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14767.795     -14767.795     -14850.547     -14850.547      320.26167      320.26167      36255.092      36255.092     -1916.73       -1916.73      
     42000  -14767.545     -14767.545     -14851.744     -14851.744      325.85819      325.85819      36209.246      36209.246      455.5004       455.5004     
Loop time of 23.9188 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.612 ns/day, 6.644 hours/ns, 41.808 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.84      | 23.84      | 23.84      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012376   | 0.012376   | 0.012376   |   0.0 |  0.05
Output  | 2.689e-05  | 2.689e-05  | 2.689e-05  |   0.0 |  0.00
Modify  | 0.061777   | 0.061777   | 0.061777   |   0.0 |  0.26
Other   |            | 0.005049   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120808 ave      120808 max      120808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120808
Ave neighs/atom = 60.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.673865429384, Press = 1.23713962816938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     42000  -14767.545     -14767.545     -14851.744     -14851.744      325.85819      325.85819      36209.246      36209.246      455.5004       455.5004     
     43000  -14764.321     -14764.321     -14849.681     -14849.681      330.352        330.352        36196.405      36196.405      1391.6783      1391.6783    
Loop time of 23.9271 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.611 ns/day, 6.646 hours/ns, 41.794 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.848     | 23.848     | 23.848     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012418   | 0.012418   | 0.012418   |   0.0 |  0.05
Output  | 2.2092e-05 | 2.2092e-05 | 2.2092e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.26
Other   |            | 0.004944   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3340 ave        3340 max        3340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121114 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.758970717599, Press = -2.01483514996554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.321     -14764.321     -14849.681     -14849.681      330.352        330.352        36196.405      36196.405      1391.6783      1391.6783    
     44000  -14764.688     -14764.688     -14852.007     -14852.007      337.93197      337.93197      36235.829      36235.829     -910.91327     -910.91327    
Loop time of 23.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.610 ns/day, 6.648 hours/ns, 41.783 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.854     | 23.854     | 23.854     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012557   | 0.012557   | 0.012557   |   0.0 |  0.05
Output  | 2.163e-05  | 2.163e-05  | 2.163e-05  |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.26
Other   |            | 0.004993   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121050 ave      121050 max      121050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121050
Ave neighs/atom = 60.525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.797320178793, Press = -0.601595753624141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.688     -14764.688     -14852.007     -14852.007      337.93197      337.93197      36235.829      36235.829     -910.91327     -910.91327    
     45000  -14768.421     -14768.421     -14850.798     -14850.798      318.80565      318.80565      36196.828      36196.828      1146.4201      1146.4201    
Loop time of 23.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.618 ns/day, 6.634 hours/ns, 41.872 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.803     | 23.803     | 23.803     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012487   | 0.012487   | 0.012487   |   0.0 |  0.05
Output  | 3.1359e-05 | 3.1359e-05 | 3.1359e-05 |   0.0 |  0.00
Modify  | 0.061757   | 0.061757   | 0.061757   |   0.0 |  0.26
Other   |            | 0.004979   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3344 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 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 = 332.866468953883, Press = -0.893834474543662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14768.421     -14768.421     -14850.798     -14850.798      318.80565      318.80565      36196.828      36196.828      1146.4201      1146.4201    
     46000  -14764.453     -14764.453     -14850.915     -14850.915      334.61945      334.61945      36229.704      36229.704     -475.34909     -475.34909    
Loop time of 23.9548 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.607 ns/day, 6.654 hours/ns, 41.745 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.875     | 23.875     | 23.875     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012523   | 0.012523   | 0.012523   |   0.0 |  0.05
Output  | 2.3504e-05 | 2.3504e-05 | 2.3504e-05 |   0.0 |  0.00
Modify  | 0.06176    | 0.06176    | 0.06176    |   0.0 |  0.26
Other   |            | 0.005033   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3383 ave        3383 max        3383 min
Histogram: 1 0 0 0 0 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 = 332.871748590073, Press = -1.44733660846333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.453     -14764.453     -14850.915     -14850.915      334.61945      334.61945      36229.704      36229.704     -475.34909     -475.34909    
     47000  -14768.08      -14768.08      -14851.081     -14851.081      321.22337      321.22337      36217.454      36217.454      61.016966      61.016966    
Loop time of 23.8633 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.621 ns/day, 6.629 hours/ns, 41.905 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.784     | 23.784     | 23.784     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012463   | 0.012463   | 0.012463   |   0.0 |  0.05
Output  | 2.7872e-05 | 2.7872e-05 | 2.7872e-05 |   0.0 |  0.00
Modify  | 0.061676   | 0.061676   | 0.061676   |   0.0 |  0.26
Other   |            | 0.004995   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3347 ave        3347 max        3347 min
Histogram: 1 0 0 0 0 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 = 332.861553324657, Press = 0.424389902829593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14768.08      -14768.08      -14851.081     -14851.081      321.22337      321.22337      36217.454      36217.454      61.016966      61.016966    
     48000  -14768.95      -14768.95      -14854.284     -14854.284      330.25092      330.25092      36188.753      36188.753      1365.4346      1365.4346    
Loop time of 23.8493 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.623 ns/day, 6.625 hours/ns, 41.930 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.77      | 23.77      | 23.77      |   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.1901e-05 | 2.1901e-05 | 2.1901e-05 |   0.0 |  0.00
Modify  | 0.061654   | 0.061654   | 0.061654   |   0.0 |  0.26
Other   |            | 0.004967   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3365 ave        3365 max        3365 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120994 ave      120994 max      120994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120994
Ave neighs/atom = 60.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.877511151685, Press = -2.06409730874051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     48000  -14768.95      -14768.95      -14854.284     -14854.284      330.25092      330.25092      36188.753      36188.753      1365.4346      1365.4346    
     49000  -14764.475     -14764.475     -14849.43      -14849.43       328.7848       328.7848       36253.932      36253.932     -1659.3708     -1659.3708    
Loop time of 23.8984 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.615 ns/day, 6.638 hours/ns, 41.844 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.819     | 23.819     | 23.819     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012474   | 0.012474   | 0.012474   |   0.0 |  0.05
Output  | 4.1608e-05 | 4.1608e-05 | 4.1608e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.26
Other   |            | 0.004937   |            |       |  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:       121114 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.841996849309, Press = -0.445698799229706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14764.475     -14764.475     -14849.43      -14849.43       328.7848       328.7848       36253.932      36253.932     -1659.3708     -1659.3708    
     50000  -14768.316     -14768.316     -14854.661     -14854.661      334.16436      334.16436      36189.856      36189.856      1326.0269      1326.0269    
Loop time of 23.8609 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.621 ns/day, 6.628 hours/ns, 41.910 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.782     | 23.782     | 23.782     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012457   | 0.012457   | 0.012457   |   0.0 |  0.05
Output  | 3.3112e-05 | 3.3112e-05 | 3.3112e-05 |   0.0 |  0.00
Modify  | 0.061578   | 0.061578   | 0.061578   |   0.0 |  0.26
Other   |            | 0.00494    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3340 ave        3340 max        3340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120830 ave      120830 max      120830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120830
Ave neighs/atom = 60.415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.781810227495, Press = -0.716631489851617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14768.316     -14768.316     -14854.661     -14854.661      334.16436      334.16436      36189.856      36189.856      1326.0269      1326.0269    
     51000  -14768.033     -14768.033     -14853.548     -14853.548      330.95017      330.95017      36225.536      36225.536     -526.0234      -526.0234     
Loop time of 23.9294 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.611 ns/day, 6.647 hours/ns, 41.790 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.85      | 23.85      | 23.85      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012472   | 0.012472   | 0.012472   |   0.0 |  0.05
Output  | 2.17e-05   | 2.17e-05   | 2.17e-05   |   0.0 |  0.00
Modify  | 0.061595   | 0.061595   | 0.061595   |   0.0 |  0.26
Other   |            | 0.004934   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3367 ave        3367 max        3367 min
Histogram: 1 0 0 0 0 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 = 332.778780938747, Press = -1.19664557159688
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14768.033     -14768.033     -14853.548     -14853.548      330.95017      330.95017      36225.536      36225.536     -526.0234      -526.0234     
     52000  -14762.446     -14762.446     -14848.824     -14848.824      334.28909      334.28909      36222.779      36222.779      47.192582      47.192582    
Loop time of 23.8743 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.619 ns/day, 6.632 hours/ns, 41.886 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.795     | 23.795     | 23.795     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012448   | 0.012448   | 0.012448   |   0.0 |  0.05
Output  | 4.6718e-05 | 4.6718e-05 | 4.6718e-05 |   0.0 |  0.00
Modify  | 0.061696   | 0.061696   | 0.061696   |   0.0 |  0.26
Other   |            | 0.004942   |            |       |  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:       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 = 332.81903805016, Press = -0.184944026636437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     52000  -14762.446     -14762.446     -14848.824     -14848.824      334.28909      334.28909      36222.779      36222.779      47.192582      47.192582    
     53000  -14765.487     -14765.487     -14851.656     -14851.656      333.48272      333.48272      36188.584      36188.584      1640.5275      1640.5275    
Loop time of 23.8617 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.621 ns/day, 6.628 hours/ns, 41.908 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.782     | 23.782     | 23.782     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012666   | 0.012666   | 0.012666   |   0.0 |  0.05
Output  | 2.1921e-05 | 2.1921e-05 | 2.1921e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.26
Other   |            | 0.00495    |            |       |  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:       120946 ave      120946 max      120946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120946
Ave neighs/atom = 60.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.844885014457, Press = -1.79754891094141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     53000  -14765.487     -14765.487     -14851.656     -14851.656      333.48272      333.48272      36188.584      36188.584      1640.5275      1640.5275    
     54000  -14762.416     -14762.416     -14850.95      -14850.95       342.63769      342.63769      36292.572      36292.572     -3832.3268     -3832.3268    
Loop time of 23.9097 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.614 ns/day, 6.642 hours/ns, 41.824 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.83      | 23.83      | 23.83      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012667   | 0.012667   | 0.012667   |   0.0 |  0.05
Output  | 2.159e-05  | 2.159e-05  | 2.159e-05  |   0.0 |  0.00
Modify  | 0.061582   | 0.061582   | 0.061582   |   0.0 |  0.26
Other   |            | 0.004961   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3391 ave        3391 max        3391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120988 ave      120988 max      120988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120988
Ave neighs/atom = 60.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.91615327294, Press = -0.363259478824368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     54000  -14762.416     -14762.416     -14850.95      -14850.95       342.63769      342.63769      36292.572      36292.572     -3832.3268     -3832.3268    
     55000  -14765.896     -14765.896     -14851.809     -14851.809      332.49177      332.49177      36177.985      36177.985      2184.4961      2184.4961    
Loop time of 23.9321 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.610 ns/day, 6.648 hours/ns, 41.785 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.853     | 23.853     | 23.853     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012483   | 0.012483   | 0.012483   |   0.0 |  0.05
Output  | 2.9035e-05 | 2.9035e-05 | 2.9035e-05 |   0.0 |  0.00
Modify  | 0.061652   | 0.061652   | 0.061652   |   0.0 |  0.26
Other   |            | 0.00495    |            |       |  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:       120732 ave      120732 max      120732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120732
Ave neighs/atom = 60.366
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.948606958274, Press = -0.543465109605217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     55000  -14765.896     -14765.896     -14851.809     -14851.809      332.49177      332.49177      36177.985      36177.985      2184.4961      2184.4961    
     56000  -14768.834     -14768.834     -14852.113     -14852.113      322.29809      322.29809      36235.797      36235.797     -1038.3741     -1038.3741    
Loop time of 23.9801 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.603 ns/day, 6.661 hours/ns, 41.701 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.901     | 23.901     | 23.901     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012581   | 0.012581   | 0.012581   |   0.0 |  0.05
Output  | 3.8903e-05 | 3.8903e-05 | 3.8903e-05 |   0.0 |  0.00
Modify  | 0.061939   | 0.061939   | 0.061939   |   0.0 |  0.26
Other   |            | 0.005011   |            |       |  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:       121036 ave      121036 max      121036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121036
Ave neighs/atom = 60.518
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.982450912452, Press = -1.13320259254807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     56000  -14768.834     -14768.834     -14852.113     -14852.113      322.29809      322.29809      36235.797      36235.797     -1038.3741     -1038.3741    
     57000  -14766.042     -14766.042     -14850.722     -14850.722      327.72031      327.72031      36201.517      36201.517      948.74757      948.74757    
Loop time of 24.0931 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.586 ns/day, 6.693 hours/ns, 41.506 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.013     | 24.013     | 24.013     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012553   | 0.012553   | 0.012553   |   0.0 |  0.05
Output  | 3.1549e-05 | 3.1549e-05 | 3.1549e-05 |   0.0 |  0.00
Modify  | 0.062465   | 0.062465   | 0.062465   |   0.0 |  0.26
Other   |            | 0.0051     |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3314 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 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 = 332.912973939248, Press = -0.0306884370309504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     57000  -14766.042     -14766.042     -14850.722     -14850.722      327.72031      327.72031      36201.517      36201.517      948.74757      948.74757    
     58000  -14766.388     -14766.388     -14853.708     -14853.708      337.93795      337.93795      36217.573      36217.573     -117.62999     -117.62999    
Loop time of 23.8474 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.623 ns/day, 6.624 hours/ns, 41.933 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.767     | 23.767     | 23.767     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012738   | 0.012738   | 0.012738   |   0.0 |  0.05
Output  | 3.0728e-05 | 3.0728e-05 | 3.0728e-05 |   0.0 |  0.00
Modify  | 0.062258   | 0.062258   | 0.062258   |   0.0 |  0.26
Other   |            | 0.005115   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3345 ave        3345 max        3345 min
Histogram: 1 0 0 0 0 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 = 332.911647066792, Press = -1.61700501102633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     58000  -14766.388     -14766.388     -14853.708     -14853.708      337.93795      337.93795      36217.573      36217.573     -117.62999     -117.62999    
     59000  -14762.899     -14762.899     -14849.967     -14849.967      336.96249      336.96249      36255.4        36255.4       -1769.6888     -1769.6888    
Loop time of 23.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.612 ns/day, 6.644 hours/ns, 41.811 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.837     | 23.837     | 23.837     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012686   | 0.012686   | 0.012686   |   0.0 |  0.05
Output  | 6.3789e-05 | 6.3789e-05 | 6.3789e-05 |   0.0 |  0.00
Modify  | 0.061973   | 0.061973   | 0.061973   |   0.0 |  0.26
Other   |            | 0.005007   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3382 ave        3382 max        3382 min
Histogram: 1 0 0 0 0 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 = 332.882824003692, Press = 0.105127173241074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     59000  -14762.899     -14762.899     -14849.967     -14849.967      336.96249      336.96249      36255.4        36255.4       -1769.6888     -1769.6888    
     60000  -14765.075     -14765.075     -14852.401     -14852.401      337.96337      337.96337      36139.003      36139.003      4259.7965      4259.7965    
Loop time of 23.8328 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.625 ns/day, 6.620 hours/ns, 41.959 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.753     | 23.753     | 23.753     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012588   | 0.012588   | 0.012588   |   0.0 |  0.05
Output  | 2.8613e-05 | 2.8613e-05 | 2.8613e-05 |   0.0 |  0.00
Modify  | 0.061869   | 0.061869   | 0.061869   |   0.0 |  0.26
Other   |            | 0.00499    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3380 ave        3380 max        3380 min
Histogram: 1 0 0 0 0 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 = 332.888526018271, Press = -1.05318468779259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     60000  -14765.075     -14765.075     -14852.401     -14852.401      337.96337      337.96337      36139.003      36139.003      4259.7965      4259.7965    
     61000  -14765.4       -14765.4       -14852.648     -14852.648      337.65961      337.65961      36257.589      36257.589     -2125.6423     -2125.6423    
Loop time of 24.0226 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.597 ns/day, 6.673 hours/ns, 41.627 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.943     | 23.943     | 23.943     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012835   | 0.012835   | 0.012835   |   0.0 |  0.05
Output  | 3.0066e-05 | 3.0066e-05 | 3.0066e-05 |   0.0 |  0.00
Modify  | 0.062119   | 0.062119   | 0.062119   |   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:           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:       121350 ave      121350 max      121350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121350
Ave neighs/atom = 60.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.959458733941, Press = -0.828111955497128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     61000  -14765.4       -14765.4       -14852.648     -14852.648      337.65961      337.65961      36257.589      36257.589     -2125.6423     -2125.6423    
     62000  -14763.286     -14763.286     -14850.542     -14850.542      337.69185      337.69185      36205.379      36205.379      850.86346      850.86346    
Loop time of 23.9024 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.615 ns/day, 6.640 hours/ns, 41.837 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.823     | 23.823     | 23.823     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012385   | 0.012385   | 0.012385   |   0.0 |  0.05
Output  | 2.706e-05  | 2.706e-05  | 2.706e-05  |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.26
Other   |            | 0.004947   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3317 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120898 ave      120898 max      120898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0