# 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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  -14864.253     -14864.253     -14940         -14940          293.15         293.15         36016.89       36016.89       2246.3865      2246.3865    
      1000  -14786.82      -14786.82      -14866.989     -14866.989      310.26302      310.26302      36149.345      36149.345      2115.7922      2115.7922    
Loop time of 12.6818 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.813 ns/day, 3.523 hours/ns, 78.853 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.606     | 12.606     | 12.606     |   0.0 | 99.40
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.011067   | 0.011067   | 0.011067   |   0.0 |  0.09
Output  | 0.00015414 | 0.00015414 | 0.00015414 |   0.0 |  0.00
Modify  | 0.059986   | 0.059986   | 0.059986   |   0.0 |  0.47
Other   |            | 0.004941   |            |       |  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  -14786.82      -14786.82      -14866.989     -14866.989      310.26302      310.26302      36149.345      36149.345      2115.7922      2115.7922    
      2000  -14785.22      -14785.22      -14857.771     -14857.771      280.78098      280.78098      36178.432      36178.432      1226.287       1226.287     
Loop time of 23.4324 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.687 ns/day, 6.509 hours/ns, 42.676 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.356     | 23.356     | 23.356     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012463   | 0.012463   | 0.012463   |   0.0 |  0.05
Output  | 5.2027e-05 | 5.2027e-05 | 5.2027e-05 |   0.0 |  0.00
Modify  | 0.059372   | 0.059372   | 0.059372   |   0.0 |  0.25
Other   |            | 0.005032   |            |       |  0.02

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

Total # of neighbors = 121158
Ave neighs/atom = 60.579
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14785.22      -14785.22      -14857.771     -14857.771      280.78098      280.78098      36178.432      36178.432      1226.287       1226.287     
      3000  -14788.805     -14788.805     -14862.701     -14862.701      285.98608      285.98608      36172.115      36172.115      990.03379      990.03379    
Loop time of 23.4851 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.679 ns/day, 6.524 hours/ns, 42.580 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.408     | 23.408     | 23.408     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012266   | 0.012266   | 0.012266   |   0.0 |  0.05
Output  | 4.0085e-05 | 4.0085e-05 | 4.0085e-05 |   0.0 |  0.00
Modify  | 0.059526   | 0.059526   | 0.059526   |   0.0 |  0.25
Other   |            | 0.005027   |            |       |  0.02

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

Total # of neighbors = 121066
Ave neighs/atom = 60.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14788.805     -14788.805     -14862.701     -14862.701      285.98608      285.98608      36172.115      36172.115      990.03379      990.03379    
      4000  -14784.604     -14784.604     -14860.666     -14860.666      294.36934      294.36934      36189.063      36189.063      487.05987      487.05987    
Loop time of 23.4864 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.679 ns/day, 6.524 hours/ns, 42.578 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.41      | 23.41      | 23.41      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012269   | 0.012269   | 0.012269   |   0.0 |  0.05
Output  | 3.4204e-05 | 3.4204e-05 | 3.4204e-05 |   0.0 |  0.00
Modify  | 0.059249   | 0.059249   | 0.059249   |   0.0 |  0.25
Other   |            | 0.004968   |            |       |  0.02

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

Total # of neighbors = 121062
Ave neighs/atom = 60.531
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14784.604     -14784.604     -14860.666     -14860.666      294.36934      294.36934      36189.063      36189.063      487.05987      487.05987    
      5000  -14788.516     -14788.516     -14863.01      -14863.01       288.29986      288.29986      36189.248      36189.248      205.25609      205.25609    
Loop time of 23.4998 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.677 ns/day, 6.528 hours/ns, 42.554 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.423     | 23.423     | 23.423     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012427   | 0.012427   | 0.012427   |   0.0 |  0.05
Output  | 2.8353e-05 | 2.8353e-05 | 2.8353e-05 |   0.0 |  0.00
Modify  | 0.059463   | 0.059463   | 0.059463   |   0.0 |  0.25
Other   |            | 0.004988   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3376 ave        3376 max        3376 min
Histogram: 1 0 0 0 0 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 = 292.1605547624, Press = 310.821858258357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.516     -14788.516     -14863.01      -14863.01       288.29986      288.29986      36189.248      36189.248      205.25609      205.25609    
      6000  -14784.617     -14784.617     -14860.965     -14860.965      295.47512      295.47512      36207.133      36207.133     -661.5833      -661.5833     
Loop time of 23.4229 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.689 ns/day, 6.506 hours/ns, 42.693 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.344     | 23.344     | 23.344     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012509   | 0.012509   | 0.012509   |   0.0 |  0.05
Output  | 2.7942e-05 | 2.7942e-05 | 2.7942e-05 |   0.0 |  0.00
Modify  | 0.061539   | 0.061539   | 0.061539   |   0.0 |  0.26
Other   |            | 0.005055   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3390 ave        3390 max        3390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121084 ave      121084 max      121084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121084
Ave neighs/atom = 60.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.00339196736, Press = 54.9971668059297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14784.617     -14784.617     -14860.965     -14860.965      295.47512      295.47512      36207.133      36207.133     -661.5833      -661.5833     
      7000  -14787.138     -14787.138     -14863.689     -14863.689      296.26167      296.26167      36223.505      36223.505     -1606.1187     -1606.1187    
Loop time of 23.3954 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.693 ns/day, 6.499 hours/ns, 42.743 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.316     | 23.316     | 23.316     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012611   | 0.012611   | 0.012611   |   0.0 |  0.05
Output  | 2.8003e-05 | 2.8003e-05 | 2.8003e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.26
Other   |            | 0.005067   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3410 ave        3410 max        3410 min
Histogram: 1 0 0 0 0 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 = 291.994673349973, Press = 22.2750751026823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.138     -14787.138     -14863.689     -14863.689      296.26167      296.26167      36223.505      36223.505     -1606.1187     -1606.1187    
      8000  -14785.341     -14785.341     -14864.353     -14864.353      305.7845       305.7845       36225.497      36225.497     -1771.948      -1771.948     
Loop time of 23.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.691 ns/day, 6.502 hours/ns, 42.719 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.33      | 23.33      | 23.33      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012456   | 0.012456   | 0.012456   |   0.0 |  0.05
Output  | 2.163e-05  | 2.163e-05  | 2.163e-05  |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.26
Other   |            | 0.005031   |            |       |  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:       120844 ave      120844 max      120844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120844
Ave neighs/atom = 60.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.061952089102, Press = 4.29797626793522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14785.341     -14785.341     -14864.353     -14864.353      305.7845       305.7845       36225.497      36225.497     -1771.948      -1771.948     
      9000  -14783.063     -14783.063     -14858.098     -14858.098      290.39516      290.39516      36209.426      36209.426     -527.39883     -527.39883    
Loop time of 23.4521 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.684 ns/day, 6.514 hours/ns, 42.640 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.373     | 23.373     | 23.373     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01231    | 0.01231    | 0.01231    |   0.0 |  0.05
Output  | 3.4485e-05 | 3.4485e-05 | 3.4485e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   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:           3337 ave        3337 max        3337 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120884 ave      120884 max      120884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120884
Ave neighs/atom = 60.442
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.230690830613, Press = 1.73330835704291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14783.063     -14783.063     -14858.098     -14858.098      290.39516      290.39516      36209.426      36209.426     -527.39883     -527.39883    
     10000  -14787.205     -14787.205     -14861.78      -14861.78       288.61474      288.61474      36218.695      36218.695     -1309.0212     -1309.0212    
Loop time of 23.458 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.683 ns/day, 6.516 hours/ns, 42.629 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.379     | 23.379     | 23.379     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01229    | 0.01229    | 0.01229    |   0.0 |  0.05
Output  | 2.2141e-05 | 2.2141e-05 | 2.2141e-05 |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.26
Other   |            | 0.00504    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3319 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 292.943894288576, Press = 1.09830302353338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.205     -14787.205     -14861.78      -14861.78       288.61474      288.61474      36218.695      36218.695     -1309.0212     -1309.0212    
     11000  -14784.888     -14784.888     -14861.707     -14861.707      297.29943      297.29943      36220.76       36220.76      -1335.9951     -1335.9951    
Loop time of 23.4148 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.690 ns/day, 6.504 hours/ns, 42.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.336     | 23.336     | 23.336     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012184   | 0.012184   | 0.012184   |   0.0 |  0.05
Output  | 3.211e-05  | 3.211e-05  | 3.211e-05  |   0.0 |  0.00
Modify  | 0.061612   | 0.061612   | 0.061612   |   0.0 |  0.26
Other   |            | 0.005034   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3301 ave        3301 max        3301 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120912 ave      120912 max      120912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120912
Ave neighs/atom = 60.456
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.034400780199, Press = -0.739015857864026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14784.888     -14784.888     -14861.707     -14861.707      297.29943      297.29943      36220.76       36220.76      -1335.9951     -1335.9951    
     12000  -14788.123     -14788.123     -14862.345     -14862.345      287.24684      287.24684      36225.271      36225.271     -1630.2267     -1630.2267    
Loop time of 23.3656 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.490 hours/ns, 42.798 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.287     | 23.287     | 23.287     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012301   | 0.012301   | 0.012301   |   0.0 |  0.05
Output  | 2.144e-05  | 2.144e-05  | 2.144e-05  |   0.0 |  0.00
Modify  | 0.061486   | 0.061486   | 0.061486   |   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:           3358 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120914 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.096947475121, Press = -2.18330748019013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.123     -14788.123     -14862.345     -14862.345      287.24684      287.24684      36225.271      36225.271     -1630.2267     -1630.2267    
     13000  -14784.784     -14784.784     -14861.683     -14861.683      297.60576      297.60576      36226.453      36226.453     -1640.6243     -1640.6243    
Loop time of 23.4745 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.681 ns/day, 6.521 hours/ns, 42.599 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.396     | 23.396     | 23.396     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01234    | 0.01234    | 0.01234    |   0.0 |  0.05
Output  | 2.9265e-05 | 2.9265e-05 | 2.9265e-05 |   0.0 |  0.00
Modify  | 0.06155    | 0.06155    | 0.06155    |   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:           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:       120932 ave      120932 max      120932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120932
Ave neighs/atom = 60.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.478831816501, Press = -5.43547985986576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14784.784     -14784.784     -14861.683     -14861.683      297.60576      297.60576      36226.453      36226.453     -1640.6243     -1640.6243    
     14000  -14787.092     -14787.092     -14863.143     -14863.143      294.32339      294.32339      36203.01       36203.01      -524.92504     -524.92504    
Loop time of 23.4742 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.681 ns/day, 6.521 hours/ns, 42.600 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.395     | 23.395     | 23.395     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012514   | 0.012514   | 0.012514   |   0.0 |  0.05
Output  | 2.135e-05  | 2.135e-05  | 2.135e-05  |   0.0 |  0.00
Modify  | 0.061555   | 0.061555   | 0.061555   |   0.0 |  0.26
Other   |            | 0.005054   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3397 ave        3397 max        3397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120968 ave      120968 max      120968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120968
Ave neighs/atom = 60.484
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.477703184476, Press = -6.18130125841626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.092     -14787.092     -14863.143     -14863.143      294.32339      294.32339      36203.01       36203.01      -524.92504     -524.92504    
     15000  -14783.914     -14783.914     -14861.604     -14861.604      300.66849      300.66849      36183.14       36183.14       662.48875      662.48875    
Loop time of 23.4866 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.679 ns/day, 6.524 hours/ns, 42.577 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.408     | 23.408     | 23.408     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012399   | 0.012399   | 0.012399   |   0.0 |  0.05
Output  | 2.137e-05  | 2.137e-05  | 2.137e-05  |   0.0 |  0.00
Modify  | 0.061568   | 0.061568   | 0.061568   |   0.0 |  0.26
Other   |            | 0.005036   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3368 ave        3368 max        3368 min
Histogram: 1 0 0 0 0 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 = 293.73274470717, Press = -3.42417802972879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14783.914     -14783.914     -14861.604     -14861.604      300.66849      300.66849      36183.14       36183.14       662.48875      662.48875    
     16000  -14787.468     -14787.468     -14862.896     -14862.896      291.9148       291.9148       36183.433      36183.433      607.43334      607.43334    
Loop time of 23.4422 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.512 hours/ns, 42.658 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.363     | 23.363     | 23.363     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012314   | 0.012314   | 0.012314   |   0.0 |  0.05
Output  | 2.8824e-05 | 2.8824e-05 | 2.8824e-05 |   0.0 |  0.00
Modify  | 0.061595   | 0.061595   | 0.061595   |   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:           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:       121124 ave      121124 max      121124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121124
Ave neighs/atom = 60.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.893754390227, Press = 0.273260261870166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     16000  -14787.468     -14787.468     -14862.896     -14862.896      291.9148       291.9148       36183.433      36183.433      607.43334      607.43334    
     17000  -14782.728     -14782.728     -14860.377     -14860.377      300.51222      300.51222      36199.146      36199.146     -13.219992     -13.219992    
Loop time of 23.3613 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.489 hours/ns, 42.806 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.283     | 23.283     | 23.283     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012087   | 0.012087   | 0.012087   |   0.0 |  0.05
Output  | 2.146e-05  | 2.146e-05  | 2.146e-05  |   0.0 |  0.00
Modify  | 0.061592   | 0.061592   | 0.061592   |   0.0 |  0.26
Other   |            | 0.004923   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3296 ave        3296 max        3296 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121106 ave      121106 max      121106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121106
Ave neighs/atom = 60.553
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.918817214529, Press = 0.732239091013416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14782.728     -14782.728     -14860.377     -14860.377      300.51222      300.51222      36199.146      36199.146     -13.219992     -13.219992    
     18000  -14788.272     -14788.272     -14865.19      -14865.19       297.6808       297.6808       36189.31       36189.31       16.392178      16.392178    
Loop time of 23.4383 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.511 hours/ns, 42.665 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.359     | 23.359     | 23.359     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012306   | 0.012306   | 0.012306   |   0.0 |  0.05
Output  | 2.7541e-05 | 2.7541e-05 | 2.7541e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.26
Other   |            | 0.004948   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3342 ave        3342 max        3342 min
Histogram: 1 0 0 0 0 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 = 294.051364893152, Press = 0.847760552804418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.272     -14788.272     -14865.19      -14865.19       297.6808       297.6808       36189.31       36189.31       16.392178      16.392178    
     19000  -14786.589     -14786.589     -14864.22      -14864.22       300.43964      300.43964      36216.126      36216.126     -1245.1832     -1245.1832    
Loop time of 23.4423 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.512 hours/ns, 42.658 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.363     | 23.363     | 23.363     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012536   | 0.012536   | 0.012536   |   0.0 |  0.05
Output  | 2.138e-05  | 2.138e-05  | 2.138e-05  |   0.0 |  0.00
Modify  | 0.061538   | 0.061538   | 0.061538   |   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:           3386 ave        3386 max        3386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121022 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.030332060164, Press = 3.05607027931785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.589     -14786.589     -14864.22      -14864.22       300.43964      300.43964      36216.126      36216.126     -1245.1832     -1245.1832    
     20000  -14786.988     -14786.988     -14863.3       -14863.3        295.33296      295.33296      36244.256      36244.256     -2627.6354     -2627.6354    
Loop time of 23.4111 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.691 ns/day, 6.503 hours/ns, 42.715 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.332     | 23.332     | 23.332     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012309   | 0.012309   | 0.012309   |   0.0 |  0.05
Output  | 2.137e-05  | 2.137e-05  | 2.137e-05  |   0.0 |  0.00
Modify  | 0.061514   | 0.061514   | 0.061514   |   0.0 |  0.26
Other   |            | 0.00493    |            |       |  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:       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 = 293.931600006748, Press = 0.982290576758549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.988     -14786.988     -14863.3       -14863.3        295.33296      295.33296      36244.256      36244.256     -2627.6354     -2627.6354    
     21000  -14788.279     -14788.279     -14864.261     -14864.261      294.05906      294.05906      36226.838      36226.838     -1899.8807     -1899.8807    
Loop time of 23.4262 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.688 ns/day, 6.507 hours/ns, 42.687 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.347     | 23.347     | 23.347     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012469   | 0.012469   | 0.012469   |   0.0 |  0.05
Output  | 3.0948e-05 | 3.0948e-05 | 3.0948e-05 |   0.0 |  0.00
Modify  | 0.061591   | 0.061591   | 0.061591   |   0.0 |  0.26
Other   |            | 0.005047   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3404 ave        3404 max        3404 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120908 ave      120908 max      120908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120908
Ave neighs/atom = 60.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.98290476706, Press = -0.444079308154231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.279     -14788.279     -14864.261     -14864.261      294.05906      294.05906      36226.838      36226.838     -1899.8807     -1899.8807    
     22000  -14784.137     -14784.137     -14861.056     -14861.056      297.68493      297.68493      36221.418      36221.418     -1281.3829     -1281.3829    
Loop time of 23.4151 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.690 ns/day, 6.504 hours/ns, 42.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.336     | 23.336     | 23.336     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012277   | 0.012277   | 0.012277   |   0.0 |  0.05
Output  | 2.1921e-05 | 2.1921e-05 | 2.1921e-05 |   0.0 |  0.00
Modify  | 0.061557   | 0.061557   | 0.061557   |   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:           3333 ave        3333 max        3333 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.953943051467, Press = -1.44256900673726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -14784.137     -14784.137     -14861.056     -14861.056      297.68493      297.68493      36221.418      36221.418     -1281.3829     -1281.3829    
     23000  -14787.333     -14787.333     -14861.47      -14861.47       286.9186       286.9186       36199.273      36199.273     -228.95623     -228.95623    
Loop time of 23.4868 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.679 ns/day, 6.524 hours/ns, 42.577 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.408     | 23.408     | 23.408     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012259   | 0.012259   | 0.012259   |   0.0 |  0.05
Output  | 2.136e-05  | 2.136e-05  | 2.136e-05  |   0.0 |  0.00
Modify  | 0.061588   | 0.061588   | 0.061588   |   0.0 |  0.26
Other   |            | 0.004997   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3318 ave        3318 max        3318 min
Histogram: 1 0 0 0 0 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 = 294.067800892335, Press = -1.03258432488336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.333     -14787.333     -14861.47      -14861.47       286.9186       286.9186       36199.273      36199.273     -228.95623     -228.95623    
     24000  -14784.947     -14784.947     -14863.813     -14863.813      305.22132      305.22132      36203.49       36203.49      -552.25        -552.25       
Loop time of 23.4208 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.689 ns/day, 6.506 hours/ns, 42.697 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.342     | 23.342     | 23.342     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012307   | 0.012307   | 0.012307   |   0.0 |  0.05
Output  | 2.8062e-05 | 2.8062e-05 | 2.8062e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   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:           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:       121024 ave      121024 max      121024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121024
Ave neighs/atom = 60.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.014426408914, Press = -0.00200876556823192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     24000  -14784.947     -14784.947     -14863.813     -14863.813      305.22132      305.22132      36203.49       36203.49      -552.25        -552.25       
     25000  -14789.25      -14789.25      -14864.808     -14864.808      292.41454      292.41454      36198.976      36198.976     -477.28808     -477.28808    
Loop time of 23.4107 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.691 ns/day, 6.503 hours/ns, 42.715 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.332     | 23.332     | 23.332     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012342   | 0.012342   | 0.012342   |   0.0 |  0.05
Output  | 2.0969e-05 | 2.0969e-05 | 2.0969e-05 |   0.0 |  0.00
Modify  | 0.061588   | 0.061588   | 0.061588   |   0.0 |  0.26
Other   |            | 0.004925   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3363 ave        3363 max        3363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 293.872649736937, Press = -0.452852782252168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14789.25      -14789.25      -14864.808     -14864.808      292.41454      292.41454      36198.976      36198.976     -477.28808     -477.28808    
     26000  -14783.485     -14783.485     -14860.719     -14860.719      298.90234      298.90234      36213.414      36213.414     -769.78601     -769.78601    
Loop time of 23.5113 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.675 ns/day, 6.531 hours/ns, 42.533 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.432     | 23.432     | 23.432     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012329   | 0.012329   | 0.012329   |   0.0 |  0.05
Output  | 2.8063e-05 | 2.8063e-05 | 2.8063e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   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:           3358 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121060 ave      121060 max      121060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121060
Ave neighs/atom = 60.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.874590000277, Press = -0.613488451051871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14783.485     -14783.485     -14860.719     -14860.719      298.90234      298.90234      36213.414      36213.414     -769.78601     -769.78601    
     27000  -14786.984     -14786.984     -14862.218     -14862.218      291.16403      291.16403      36223.971      36223.971     -1585.894      -1585.894     
Loop time of 23.4211 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.689 ns/day, 6.506 hours/ns, 42.697 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.342     | 23.342     | 23.342     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01243    | 0.01243    | 0.01243    |   0.0 |  0.05
Output  | 2.164e-05  | 2.164e-05  | 2.164e-05  |   0.0 |  0.00
Modify  | 0.061635   | 0.061635   | 0.061635   |   0.0 |  0.26
Other   |            | 0.004945   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3368 ave        3368 max        3368 min
Histogram: 1 0 0 0 0 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 = 293.921877058549, Press = -2.14189258994071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.984     -14786.984     -14862.218     -14862.218      291.16403      291.16403      36223.971      36223.971     -1585.894      -1585.894     
     28000  -14784.524     -14784.524     -14862.565     -14862.565      302.02831      302.02831      36199.969      36199.969     -229.8643      -229.8643     
Loop time of 23.5072 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.675 ns/day, 6.530 hours/ns, 42.540 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.428     | 23.428     | 23.428     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012378   | 0.012378   | 0.012378   |   0.0 |  0.05
Output  | 2.1881e-05 | 2.1881e-05 | 2.1881e-05 |   0.0 |  0.00
Modify  | 0.061634   | 0.061634   | 0.061634   |   0.0 |  0.26
Other   |            | 0.004981   |            |       |  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:       120890 ave      120890 max      120890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120890
Ave neighs/atom = 60.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.909677374631, Press = -2.57886150874678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     28000  -14784.524     -14784.524     -14862.565     -14862.565      302.02831      302.02831      36199.969      36199.969     -229.8643      -229.8643     
     29000  -14787.812     -14787.812     -14862.97      -14862.97       290.86582      290.86582      36179.841      36179.841      710.35864      710.35864    
Loop time of 23.3984 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.693 ns/day, 6.500 hours/ns, 42.738 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.319     | 23.319     | 23.319     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012456   | 0.012456   | 0.012456   |   0.0 |  0.05
Output  | 2.9365e-05 | 2.9365e-05 | 2.9365e-05 |   0.0 |  0.00
Modify  | 0.061751   | 0.061751   | 0.061751   |   0.0 |  0.26
Other   |            | 0.005048   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3308 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 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 = 293.797389919595, Press = -1.8533226406296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.812     -14787.812     -14862.97      -14862.97       290.86582      290.86582      36179.841      36179.841      710.35864      710.35864    
     30000  -14788.189     -14788.189     -14864.068     -14864.068      293.65973      293.65973      36173.46       36173.46       972.70956      972.70956    
Loop time of 23.3453 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.701 ns/day, 6.485 hours/ns, 42.835 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.266     | 23.266     | 23.266     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012269   | 0.012269   | 0.012269   |   0.0 |  0.05
Output  | 2.1441e-05 | 2.1441e-05 | 2.1441e-05 |   0.0 |  0.00
Modify  | 0.061512   | 0.061512   | 0.061512   |   0.0 |  0.26
Other   |            | 0.005023   |            |       |  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:       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 = 293.745958594463, Press = -0.913749879182082
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.189     -14788.189     -14864.068     -14864.068      293.65973      293.65973      36173.46       36173.46       972.70956      972.70956    
     31000  -14786.076     -14786.076     -14861.542     -14861.542      292.06055      292.06055      36170.197      36170.197      1397.3842      1397.3842    
Loop time of 23.3893 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.694 ns/day, 6.497 hours/ns, 42.755 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.31      | 23.31      | 23.31      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012507   | 0.012507   | 0.012507   |   0.0 |  0.05
Output  | 2.7862e-05 | 2.7862e-05 | 2.7862e-05 |   0.0 |  0.00
Modify  | 0.061548   | 0.061548   | 0.061548   |   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:           3417 ave        3417 max        3417 min
Histogram: 1 0 0 0 0 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 = 293.595894084545, Press = -0.0817727527602464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.076     -14786.076     -14861.542     -14861.542      292.06055      292.06055      36170.197      36170.197      1397.3842      1397.3842    
     32000  -14787.764     -14787.764     -14863.837     -14863.837      294.41051      294.41051      36183.688      36183.688      437.19424      437.19424    
Loop time of 23.4159 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.690 ns/day, 6.504 hours/ns, 42.706 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.337     | 23.337     | 23.337     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012355   | 0.012355   | 0.012355   |   0.0 |  0.05
Output  | 2.112e-05  | 2.112e-05  | 2.112e-05  |   0.0 |  0.00
Modify  | 0.061575   | 0.061575   | 0.061575   |   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:           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:       121156 ave      121156 max      121156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121156
Ave neighs/atom = 60.578
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.664229136554, Press = 0.00695217879508315
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.764     -14787.764     -14863.837     -14863.837      294.41051      294.41051      36183.688      36183.688      437.19424      437.19424    
     33000  -14783.054     -14783.054     -14861.847     -14861.847      304.93458      304.93458      36186.092      36186.092      534.56736      534.56736    
Loop time of 23.4391 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.511 hours/ns, 42.664 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.36      | 23.36      | 23.36      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012434   | 0.012434   | 0.012434   |   0.0 |  0.05
Output  | 2.138e-05  | 2.138e-05  | 2.138e-05  |   0.0 |  0.00
Modify  | 0.061608   | 0.061608   | 0.061608   |   0.0 |  0.26
Other   |            | 0.005035   |            |       |  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:       121084 ave      121084 max      121084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121084
Ave neighs/atom = 60.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.719005578875, Press = 0.127756504108535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14783.054     -14783.054     -14861.847     -14861.847      304.93458      304.93458      36186.092      36186.092      534.56736      534.56736    
     34000  -14787.316     -14787.316     -14863.037     -14863.037      293.04676      293.04676      36185.801      36185.801      317.97956      317.97956    
Loop time of 23.4676 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.682 ns/day, 6.519 hours/ns, 42.612 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.388     | 23.388     | 23.388     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01244    | 0.01244    | 0.01244    |   0.0 |  0.05
Output  | 2.7672e-05 | 2.7672e-05 | 2.7672e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.26
Other   |            | 0.005034   |            |       |  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 = 293.761137245403, Press = -0.0712105332093368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.316     -14787.316     -14863.037     -14863.037      293.04676      293.04676      36185.801      36185.801      317.97956      317.97956    
     35000  -14789.453     -14789.453     -14863.094     -14863.094      284.99895      284.99895      36181.657      36181.657      489.98241      489.98241    
Loop time of 23.4127 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.690 ns/day, 6.504 hours/ns, 42.712 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.334     | 23.334     | 23.334     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012312   | 0.012312   | 0.012312   |   0.0 |  0.05
Output  | 2.1049e-05 | 2.1049e-05 | 2.1049e-05 |   0.0 |  0.00
Modify  | 0.061496   | 0.061496   | 0.061496   |   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:           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:       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 = 293.77659086926, Press = -0.0589162458682922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14789.453     -14789.453     -14863.094     -14863.094      284.99895      284.99895      36181.657      36181.657      489.98241      489.98241    
     36000  -14785.435     -14785.435     -14864.545     -14864.545      306.16555      306.16555      36190.113      36190.113      111.06         111.06       
Loop time of 23.4483 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.685 ns/day, 6.513 hours/ns, 42.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.369     | 23.369     | 23.369     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012574   | 0.012574   | 0.012574   |   0.0 |  0.05
Output  | 2.7471e-05 | 2.7471e-05 | 2.7471e-05 |   0.0 |  0.00
Modify  | 0.061515   | 0.061515   | 0.061515   |   0.0 |  0.26
Other   |            | 0.005066   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3407 ave        3407 max        3407 min
Histogram: 1 0 0 0 0 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 = 293.704878438562, Press = 0.264780614137601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14785.435     -14785.435     -14864.545     -14864.545      306.16555      306.16555      36190.113      36190.113      111.06         111.06       
     37000  -14790.176     -14790.176     -14863.474     -14863.474      283.66807      283.66807      36196.3        36196.3       -289.67413     -289.67413    
Loop time of 23.3895 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.694 ns/day, 6.497 hours/ns, 42.754 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.311     | 23.311     | 23.311     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012187   | 0.012187   | 0.012187   |   0.0 |  0.05
Output  | 2.137e-05  | 2.137e-05  | 2.137e-05  |   0.0 |  0.00
Modify  | 0.061528   | 0.061528   | 0.061528   |   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:           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:       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 = 293.596333476876, Press = 0.755243647924635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14790.176     -14790.176     -14863.474     -14863.474      283.66807      283.66807      36196.3        36196.3       -289.67413     -289.67413    
     38000  -14786.667     -14786.667     -14860.921     -14860.921      287.36938      287.36938      36230.843      36230.843     -1869.9724     -1869.9724    
Loop time of 23.4254 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.688 ns/day, 6.507 hours/ns, 42.689 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.346     | 23.346     | 23.346     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012466   | 0.012466   | 0.012466   |   0.0 |  0.05
Output  | 2.119e-05  | 2.119e-05  | 2.119e-05  |   0.0 |  0.00
Modify  | 0.061549   | 0.061549   | 0.061549   |   0.0 |  0.26
Other   |            | 0.005042   |            |       |  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:       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 = 293.564286065046, Press = 0.663332612068867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.667     -14786.667     -14860.921     -14860.921      287.36938      287.36938      36230.843      36230.843     -1869.9724     -1869.9724    
     39000  -14786.297     -14786.297     -14862.904     -14862.904      296.47697      296.47697      36244.391      36244.391     -2715.6452     -2715.6452    
Loop time of 23.4164 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.690 ns/day, 6.505 hours/ns, 42.705 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.338     | 23.338     | 23.338     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012303   | 0.012303   | 0.012303   |   0.0 |  0.05
Output  | 2.7792e-05 | 2.7792e-05 | 2.7792e-05 |   0.0 |  0.00
Modify  | 0.061513   | 0.061513   | 0.061513   |   0.0 |  0.26
Other   |            | 0.005034   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3359 ave        3359 max        3359 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120896 ave      120896 max      120896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120896
Ave neighs/atom = 60.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.53003437935, Press = -0.192685171037865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     39000  -14786.297     -14786.297     -14862.904     -14862.904      296.47697      296.47697      36244.391      36244.391     -2715.6452     -2715.6452    
     40000  -14789.45      -14789.45      -14864.593     -14864.593      290.8112       290.8112       36216.488      36216.488     -1410.4638     -1410.4638    
Loop time of 23.4028 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.692 ns/day, 6.501 hours/ns, 42.730 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.324     | 23.324     | 23.324     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012109   | 0.012109   | 0.012109   |   0.0 |  0.05
Output  | 2.128e-05  | 2.128e-05  | 2.128e-05  |   0.0 |  0.00
Modify  | 0.061482   | 0.061482   | 0.061482   |   0.0 |  0.26
Other   |            | 0.004985   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3298 ave        3298 max        3298 min
Histogram: 1 0 0 0 0 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 = 293.506879353217, Press = -0.566242805654785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14789.45      -14789.45      -14864.593     -14864.593      290.8112       290.8112       36216.488      36216.488     -1410.4638     -1410.4638    
     41000  -14785.828     -14785.828     -14862.432     -14862.432      296.46479      296.46479      36202.766      36202.766     -501.3607      -501.3607     
Loop time of 23.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.494 hours/ns, 42.773 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.3       | 23.3       | 23.3       |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012254   | 0.012254   | 0.012254   |   0.0 |  0.05
Output  | 2.141e-05  | 2.141e-05  | 2.141e-05  |   0.0 |  0.00
Modify  | 0.061563   | 0.061563   | 0.061563   |   0.0 |  0.26
Other   |            | 0.005014   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3346 ave        3346 max        3346 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120880 ave      120880 max      120880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120880
Ave neighs/atom = 60.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.444788182033, Press = -0.517271068001897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14785.828     -14785.828     -14862.432     -14862.432      296.46479      296.46479      36202.766      36202.766     -501.3607      -501.3607     
     42000  -14790.808     -14790.808     -14864.667     -14864.667      285.84082      285.84082      36196.428      36196.428     -507.27456     -507.27456    
Loop time of 23.4386 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.511 hours/ns, 42.665 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.36      | 23.36      | 23.36      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012355   | 0.012355   | 0.012355   |   0.0 |  0.05
Output  | 2.7903e-05 | 2.7903e-05 | 2.7903e-05 |   0.0 |  0.00
Modify  | 0.061491   | 0.061491   | 0.061491   |   0.0 |  0.26
Other   |            | 0.005047   |            |       |  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:       121004 ave      121004 max      121004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121004
Ave neighs/atom = 60.502
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.371285275114, Press = -0.588169592493194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14790.808     -14790.808     -14864.667     -14864.667      285.84082      285.84082      36196.428      36196.428     -507.27456     -507.27456    
     43000  -14785.64      -14785.64      -14862.636     -14862.636      297.98323      297.98323      36202.136      36202.136     -436.90796     -436.90796    
Loop time of 23.4262 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.688 ns/day, 6.507 hours/ns, 42.687 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.347     | 23.347     | 23.347     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012427   | 0.012427   | 0.012427   |   0.0 |  0.05
Output  | 2.119e-05  | 2.119e-05  | 2.119e-05  |   0.0 |  0.00
Modify  | 0.061548   | 0.061548   | 0.061548   |   0.0 |  0.26
Other   |            | 0.00503    |            |       |  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:       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 = 293.328117564051, Press = -0.796735946405327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14785.64      -14785.64      -14862.636     -14862.636      297.98323      297.98323      36202.136      36202.136     -436.90796     -436.90796    
     44000  -14788.367     -14788.367     -14864.71      -14864.71       295.45443      295.45443      36170.93       36170.93       1011.0433      1011.0433    
Loop time of 23.5214 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.673 ns/day, 6.534 hours/ns, 42.514 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.443     | 23.443     | 23.443     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012333   | 0.012333   | 0.012333   |   0.0 |  0.05
Output  | 2.7602e-05 | 2.7602e-05 | 2.7602e-05 |   0.0 |  0.00
Modify  | 0.061542   | 0.061542   | 0.061542   |   0.0 |  0.26
Other   |            | 0.004958   |            |       |  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:       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 = 293.32558784968, Press = -1.78399028579421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.367     -14788.367     -14864.71      -14864.71       295.45443      295.45443      36170.93       36170.93       1011.0433      1011.0433    
     45000  -14786.023     -14786.023     -14864.628     -14864.628      304.20988      304.20988      36143.503      36143.503      2535.6568      2535.6568    
Loop time of 23.4675 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.682 ns/day, 6.519 hours/ns, 42.612 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.389     | 23.389     | 23.389     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012333   | 0.012333   | 0.012333   |   0.0 |  0.05
Output  | 2.1501e-05 | 2.1501e-05 | 2.1501e-05 |   0.0 |  0.00
Modify  | 0.061477   | 0.061477   | 0.061477   |   0.0 |  0.26
Other   |            | 0.004935   |            |       |  0.02

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

Total # of neighbors = 121090
Ave neighs/atom = 60.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.382578691236, Press = -1.1706505606194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14786.023     -14786.023     -14864.628     -14864.628      304.20988      304.20988      36143.503      36143.503      2535.6568      2535.6568    
     46000  -14784.152     -14784.152     -14860.789     -14860.789      296.59138      296.59138      36156.285      36156.285      2208.3763      2208.3763    
Loop time of 23.5919 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.662 ns/day, 6.553 hours/ns, 42.387 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.513     | 23.513     | 23.513     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012447   | 0.012447   | 0.012447   |   0.0 |  0.05
Output  | 3.4806e-05 | 3.4806e-05 | 3.4806e-05 |   0.0 |  0.00
Modify  | 0.061856   | 0.061856   | 0.061856   |   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:           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:       121200 ave      121200 max      121200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121200
Ave neighs/atom = 60.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.407161611945, Press = -0.203553616311078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14784.152     -14784.152     -14860.789     -14860.789      296.59138      296.59138      36156.285      36156.285      2208.3763      2208.3763    
     47000  -14787.942     -14787.942     -14862.679     -14862.679      289.24017      289.24017      36169.894      36169.894      1198.4848      1198.4848    
Loop time of 23.5313 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.672 ns/day, 6.536 hours/ns, 42.497 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.452     | 23.452     | 23.452     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012511   | 0.012511   | 0.012511   |   0.0 |  0.05
Output  | 3.154e-05  | 3.154e-05  | 3.154e-05  |   0.0 |  0.00
Modify  | 0.061997   | 0.061997   | 0.061997   |   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:           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:       121104 ave      121104 max      121104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121104
Ave neighs/atom = 60.552
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.408826812404, Press = 0.288560390329094
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14787.942     -14787.942     -14862.679     -14862.679      289.24017      289.24017      36169.894      36169.894      1198.4848      1198.4848    
     48000  -14788.57      -14788.57      -14862.572     -14862.572      286.39485      286.39485      36184.161      36184.161      433.24403      433.24403    
Loop time of 23.4378 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.686 ns/day, 6.511 hours/ns, 42.666 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.359     | 23.359     | 23.359     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012347   | 0.012347   | 0.012347   |   0.0 |  0.05
Output  | 2.7582e-05 | 2.7582e-05 | 2.7582e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.26
Other   |            | 0.004939   |            |       |  0.02

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

Total # of neighbors = 121136
Ave neighs/atom = 60.568
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.386042246794, Press = 0.33402855772301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.57      -14788.57      -14862.572     -14862.572      286.39485      286.39485      36184.161      36184.161      433.24403      433.24403    
     49000  -14785.344     -14785.344     -14861.501     -14861.501      294.73209      294.73209      36204.628      36204.628     -449.89153     -449.89153    
Loop time of 23.3511 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.486 hours/ns, 42.824 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.272     | 23.272     | 23.272     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012316   | 0.012316   | 0.012316   |   0.0 |  0.05
Output  | 2.7562e-05 | 2.7562e-05 | 2.7562e-05 |   0.0 |  0.00
Modify  | 0.061544   | 0.061544   | 0.061544   |   0.0 |  0.26
Other   |            | 0.004939   |            |       |  0.02

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

Total # of neighbors = 121084
Ave neighs/atom = 60.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.315097916277, Press = 0.4894371108759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14785.344     -14785.344     -14861.501     -14861.501      294.73209      294.73209      36204.628      36204.628     -449.89153     -449.89153    
     50000  -14788.324     -14788.324     -14864.731     -14864.731      295.70077      295.70077      36249.487      36249.487     -3158.1851     -3158.1851    
Loop time of 23.3332 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.481 hours/ns, 42.857 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.254     | 23.254     | 23.254     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01245    | 0.01245    | 0.01245    |   0.0 |  0.05
Output  | 3.0276e-05 | 3.0276e-05 | 3.0276e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.26
Other   |            | 0.004951   |            |       |  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:       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 = 293.289784304096, Press = 0.69863361547539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14788.324     -14788.324     -14864.731     -14864.731      295.70077      295.70077      36249.487      36249.487     -3158.1851     -3158.1851    
     51000  -14787.346     -14787.346     -14862.584     -14862.584      291.17637      291.17637      36242.294      36242.294     -2635.5887     -2635.5887    
Loop time of 23.3129 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.895 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.233     | 23.233     | 23.233     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012543   | 0.012543   | 0.012543   |   0.0 |  0.05
Output  | 3.0036e-05 | 3.0036e-05 | 3.0036e-05 |   0.0 |  0.00
Modify  | 0.061934   | 0.061934   | 0.061934   |   0.0 |  0.27
Other   |            | 0.005005   |            |       |  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:       120822 ave      120822 max      120822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120822
Ave neighs/atom = 60.411
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
36193.8632531634

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0