# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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  -14874.588     -14874.588     -14940         -14940          253.15         253.15         36016.89       36016.89       1939.8725      1939.8725    
      1000  -14808.174     -14808.174     -14875.685     -14875.685      261.27569      261.27569      36186.043      36186.043     -1073.9913     -1073.9913    
Loop time of 12.3807 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.979 ns/day, 3.439 hours/ns, 80.771 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.305     | 12.305     | 12.305     |   0.0 | 99.39
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.011062   | 0.011062   | 0.011062   |   0.0 |  0.09
Output  | 0.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.060004   | 0.060004   | 0.060004   |   0.0 |  0.48
Other   |            | 0.004886   |            |       |  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  -14808.174     -14808.174     -14875.685     -14875.685      261.27569      261.27569      36186.043      36186.043     -1073.9913     -1073.9913    
      2000  -14806.405     -14806.405     -14869.358     -14869.358      243.63317      243.63317      36172.695      36172.695      152.73472      152.73472    
Loop time of 23.0615 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.747 ns/day, 6.406 hours/ns, 43.362 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    | 22.983     | 22.983     | 22.983     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012889   | 0.012889   | 0.012889   |   0.0 |  0.06
Output  | 0.00012352 | 0.00012352 | 0.00012352 |   0.0 |  0.00
Modify  | 0.060022   | 0.060022   | 0.060022   |   0.0 |  0.26
Other   |            | 0.005149   |            |       |  0.02

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

Total # of neighbors = 121044
Ave neighs/atom = 60.522
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14806.405     -14806.405     -14869.358     -14869.358      243.63317      243.63317      36172.695      36172.695      152.73472      152.73472    
      3000  -14809.709     -14809.709     -14872.238     -14872.238      241.99472      241.99472      36154.021      36154.021      720.14729      720.14729    
Loop time of 23.1597 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.731 ns/day, 6.433 hours/ns, 43.178 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.082     | 23.082     | 23.082     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012622   | 0.012622   | 0.012622   |   0.0 |  0.05
Output  | 0.00011006 | 0.00011006 | 0.00011006 |   0.0 |  0.00
Modify  | 0.060101   | 0.060101   | 0.060101   |   0.0 |  0.26
Other   |            | 0.005076   |            |       |  0.02

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

Total # of neighbors = 121008
Ave neighs/atom = 60.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14809.709     -14809.709     -14872.238     -14872.238      241.99472      241.99472      36154.021      36154.021      720.14729      720.14729    
      4000  -14806.074     -14806.074     -14870.705     -14870.705      250.12935      250.12935      36147.02       36147.02       1394.9562      1394.9562    
Loop time of 23.1189 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.737 ns/day, 6.422 hours/ns, 43.255 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.041     | 23.041     | 23.041     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012739   | 0.012739   | 0.012739   |   0.0 |  0.06
Output  | 0.00013387 | 0.00013387 | 0.00013387 |   0.0 |  0.00
Modify  | 0.060143   | 0.060143   | 0.060143   |   0.0 |  0.26
Other   |            | 0.005077   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3347 ave        3347 max        3347 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121166 ave      121166 max      121166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121166
Ave neighs/atom = 60.583
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -14806.074     -14806.074     -14870.705     -14870.705      250.12935      250.12935      36147.02       36147.02       1394.9562      1394.9562    
      5000  -14809.601     -14809.601     -14874.301     -14874.301      250.39798      250.39798      36197.335      36197.335     -1601.5022     -1601.5022    
Loop time of 23.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.744 ns/day, 6.411 hours/ns, 43.331 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23         | 23         | 23         |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012434   | 0.012434   | 0.012434   |   0.0 |  0.05
Output  | 3.2121e-05 | 3.2121e-05 | 3.2121e-05 |   0.0 |  0.00
Modify  | 0.060074   | 0.060074   | 0.060074   |   0.0 |  0.26
Other   |            | 0.005019   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           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:       121170 ave      121170 max      121170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121170
Ave neighs/atom = 60.585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.218770795681, Press = 116.804518525813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14809.601     -14809.601     -14874.301     -14874.301      250.39798      250.39798      36197.335      36197.335     -1601.5022     -1601.5022    
      6000  -14807.797     -14807.797     -14875.468     -14875.468      261.89225      261.89225      36191.259      36191.259     -1385.8678     -1385.8678    
Loop time of 23.0787 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.744 ns/day, 6.411 hours/ns, 43.330 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 22.998     | 22.998     | 22.998     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012859   | 0.012859   | 0.012859   |   0.0 |  0.06
Output  | 4.8e-05    | 4.8e-05    | 4.8e-05    |   0.0 |  0.00
Modify  | 0.062411   | 0.062411   | 0.062411   |   0.0 |  0.27
Other   |            | 0.005038   |            |       |  0.02

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

Total # of neighbors = 120984
Ave neighs/atom = 60.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.834805006309, Press = 44.9875623530697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.797     -14807.797     -14875.468     -14875.468      261.89225      261.89225      36191.259      36191.259     -1385.8678     -1385.8678    
      7000  -14806.134     -14806.134     -14872.838     -14872.838      258.15025      258.15025      36133.968      36133.968      1865.9775      1865.9775    
Loop time of 23.1734 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.728 ns/day, 6.437 hours/ns, 43.153 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.093     | 23.093     | 23.093     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012809   | 0.012809   | 0.012809   |   0.0 |  0.06
Output  | 9.0089e-05 | 9.0089e-05 | 9.0089e-05 |   0.0 |  0.00
Modify  | 0.062425   | 0.062425   | 0.062425   |   0.0 |  0.27
Other   |            | 0.005058   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3402 ave        3402 max        3402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 253.751592105354, Press = 26.1113437707978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.134     -14806.134     -14872.838     -14872.838      258.15025      258.15025      36133.968      36133.968      1865.9775      1865.9775    
      8000  -14807.706     -14807.706     -14871.347     -14871.347      246.29909      246.29909      36139.231      36139.231      1606.6232      1606.6232    
Loop time of 23.2013 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.724 ns/day, 6.445 hours/ns, 43.101 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.121     | 23.121     | 23.121     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012893   | 0.012893   | 0.012893   |   0.0 |  0.06
Output  | 4.6377e-05 | 4.6377e-05 | 4.6377e-05 |   0.0 |  0.00
Modify  | 0.062119   | 0.062119   | 0.062119   |   0.0 |  0.27
Other   |            | 0.00503    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3445 ave        3445 max        3445 min
Histogram: 1 0 0 0 0 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 = 254.460733775021, Press = -2.74152519914247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.706     -14807.706     -14871.347     -14871.347      246.29909      246.29909      36139.231      36139.231      1606.6232      1606.6232    
      9000  -14806.737     -14806.737     -14874.259     -14874.259      261.31831      261.31831      36197.643      36197.643     -1587.0934     -1587.0934    
Loop time of 23.2552 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.715 ns/day, 6.460 hours/ns, 43.001 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.173     | 23.173     | 23.173     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01314    | 0.01314    | 0.01314    |   0.0 |  0.06
Output  | 9.3064e-05 | 9.3064e-05 | 9.3064e-05 |   0.0 |  0.00
Modify  | 0.063029   | 0.063029   | 0.063029   |   0.0 |  0.27
Other   |            | 0.005536   |            |       |  0.02

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

Total # of neighbors = 121234
Ave neighs/atom = 60.617
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.309718868203, Press = 3.99755927601003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.737     -14806.737     -14874.259     -14874.259      261.31831      261.31831      36197.643      36197.643     -1587.0934     -1587.0934    
     10000  -14807.352     -14807.352     -14875.467     -14875.467      263.61022      263.61022      36174.07       36174.07      -347.27637     -347.27637    
Loop time of 22.9829 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.759 ns/day, 6.384 hours/ns, 43.511 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    | 22.904     | 22.904     | 22.904     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012338   | 0.012338   | 0.012338   |   0.0 |  0.05
Output  | 2.9876e-05 | 2.9876e-05 | 2.9876e-05 |   0.0 |  0.00
Modify  | 0.061605   | 0.061605   | 0.061605   |   0.0 |  0.27
Other   |            | 0.004917   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3352 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 254.756558279334, Press = 9.32721818100171
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -14807.352     -14807.352     -14875.467     -14875.467      263.61022      263.61022      36174.07       36174.07      -347.27637     -347.27637    
     11000  -14806.016     -14806.016     -14873.225     -14873.225      260.10647      260.10647      36148.305      36148.305      1235.3167      1235.3167    
Loop time of 23.1537 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.732 ns/day, 6.432 hours/ns, 43.190 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.074     | 23.074     | 23.074     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012472   | 0.012472   | 0.012472   |   0.0 |  0.05
Output  | 4.1017e-05 | 4.1017e-05 | 4.1017e-05 |   0.0 |  0.00
Modify  | 0.062445   | 0.062445   | 0.062445   |   0.0 |  0.27
Other   |            | 0.00508    |            |       |  0.02

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

Total # of neighbors = 120922
Ave neighs/atom = 60.461
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.591393333483, Press = 3.9529389871035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.016     -14806.016     -14873.225     -14873.225      260.10647      260.10647      36148.305      36148.305      1235.3167      1235.3167    
     12000  -14807.773     -14807.773     -14872.283     -14872.283      249.66012      249.66012      36188.828      36188.828     -1042.5885     -1042.5885    
Loop time of 22.9768 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.760 ns/day, 6.382 hours/ns, 43.522 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    | 22.897     | 22.897     | 22.897     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012715   | 0.012715   | 0.012715   |   0.0 |  0.06
Output  | 3.4394e-05 | 3.4394e-05 | 3.4394e-05 |   0.0 |  0.00
Modify  | 0.061947   | 0.061947   | 0.061947   |   0.0 |  0.27
Other   |            | 0.004961   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3381 ave        3381 max        3381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 254.30445503993, Press = 2.18044800889739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.773     -14807.773     -14872.283     -14872.283      249.66012      249.66012      36188.828      36188.828     -1042.5885     -1042.5885    
     13000  -14807.975     -14807.975     -14872.142     -14872.142      248.33219      248.33219      36173.199      36173.199     -200.16103     -200.16103    
Loop time of 23.3812 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.695 ns/day, 6.495 hours/ns, 42.769 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.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012998   | 0.012998   | 0.012998   |   0.0 |  0.06
Output  | 3.0266e-05 | 3.0266e-05 | 3.0266e-05 |   0.0 |  0.00
Modify  | 0.063004   | 0.063004   | 0.063004   |   0.0 |  0.27
Other   |            | 0.005136   |            |       |  0.02

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

Total # of neighbors = 121038
Ave neighs/atom = 60.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.210472204782, Press = 6.09737200080353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.975     -14807.975     -14872.142     -14872.142      248.33219      248.33219      36173.199      36173.199     -200.16103     -200.16103    
     14000  -14810.679     -14810.679     -14873.551     -14873.551      243.32111      243.32111      36138.168      36138.168      1552.5968      1552.5968    
Loop time of 23.0377 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.750 ns/day, 6.399 hours/ns, 43.407 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    | 22.957     | 22.957     | 22.957     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.013007   | 0.013007   | 0.013007   |   0.0 |  0.06
Output  | 4.6617e-05 | 4.6617e-05 | 4.6617e-05 |   0.0 |  0.00
Modify  | 0.062162   | 0.062162   | 0.062162   |   0.0 |  0.27
Other   |            | 0.004985   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3438 ave        3438 max        3438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121070 ave      121070 max      121070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121070
Ave neighs/atom = 60.535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.7795691469, Press = 4.36962885048182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14810.679     -14810.679     -14873.551     -14873.551      243.32111      243.32111      36138.168      36138.168      1552.5968      1552.5968    
     15000  -14807.318     -14807.318     -14874.158     -14874.158      258.67872      258.67872      36162.028      36162.028      304.87981      304.87981    
Loop time of 23.2406 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.718 ns/day, 6.456 hours/ns, 43.028 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.16      | 23.16      | 23.16      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012676   | 0.012676   | 0.012676   |   0.0 |  0.05
Output  | 9.8785e-05 | 9.8785e-05 | 9.8785e-05 |   0.0 |  0.00
Modify  | 0.062354   | 0.062354   | 0.062354   |   0.0 |  0.27
Other   |            | 0.004999   |            |       |  0.02

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

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.614871469009, Press = -0.340939072015496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.318     -14807.318     -14874.158     -14874.158      258.67872      258.67872      36162.028      36162.028      304.87981      304.87981    
     16000  -14809.298     -14809.298     -14875.738     -14875.738      257.13136      257.13136      36227.943      36227.943     -3358.6492     -3358.6492    
Loop time of 23.1728 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.729 ns/day, 6.437 hours/ns, 43.154 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.092     | 23.092     | 23.092     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012763   | 0.012763   | 0.012763   |   0.0 |  0.06
Output  | 3.0457e-05 | 3.0457e-05 | 3.0457e-05 |   0.0 |  0.00
Modify  | 0.062582   | 0.062582   | 0.062582   |   0.0 |  0.27
Other   |            | 0.005063   |            |       |  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:       121100 ave      121100 max      121100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121100
Ave neighs/atom = 60.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.353911476775, Press = 2.4262324384167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14809.298     -14809.298     -14875.738     -14875.738      257.13136      257.13136      36227.943      36227.943     -3358.6492     -3358.6492    
     17000  -14809.289     -14809.289     -14874.641     -14874.641      252.91975      252.91975      36153.761      36153.761      653.77685      653.77685    
Loop time of 22.9089 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.771 ns/day, 6.364 hours/ns, 43.651 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    | 22.83      | 22.83      | 22.83      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012045   | 0.012045   | 0.012045   |   0.0 |  0.05
Output  | 5.0174e-05 | 5.0174e-05 | 5.0174e-05 |   0.0 |  0.00
Modify  | 0.061548   | 0.061548   | 0.061548   |   0.0 |  0.27
Other   |            | 0.004894   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3293 ave        3293 max        3293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120778 ave      120778 max      120778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120778
Ave neighs/atom = 60.389
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.360222556963, Press = 5.44621253466033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14809.289     -14809.289     -14874.641     -14874.641      252.91975      252.91975      36153.761      36153.761      653.77685      653.77685    
     18000  -14809.266     -14809.266     -14871.905     -14871.905      242.41848      242.41848      36149.834      36149.834      1006.3687      1006.3687    
Loop time of 22.9619 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.763 ns/day, 6.378 hours/ns, 43.550 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    | 22.883     | 22.883     | 22.883     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012356   | 0.012356   | 0.012356   |   0.0 |  0.05
Output  | 3.194e-05  | 3.194e-05  | 3.194e-05  |   0.0 |  0.00
Modify  | 0.061462   | 0.061462   | 0.061462   |   0.0 |  0.27
Other   |            | 0.00485    |            |       |  0.02

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

Total # of neighbors = 121172
Ave neighs/atom = 60.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.336294343485, Press = 2.12042965184283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14809.266     -14809.266     -14871.905     -14871.905      242.41848      242.41848      36149.834      36149.834      1006.3687      1006.3687    
     19000  -14806.434     -14806.434     -14871.704     -14871.704      252.60255      252.60255      36184.687      36184.687     -730.42497     -730.42497    
Loop time of 23.3977 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.693 ns/day, 6.499 hours/ns, 42.739 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.317     | 23.317     | 23.317     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012871   | 0.012871   | 0.012871   |   0.0 |  0.06
Output  | 3.1178e-05 | 3.1178e-05 | 3.1178e-05 |   0.0 |  0.00
Modify  | 0.062743   | 0.062743   | 0.062743   |   0.0 |  0.27
Other   |            | 0.005033   |            |       |  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:       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 = 253.414067165729, Press = 1.31186334223016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.434     -14806.434     -14871.704     -14871.704      252.60255      252.60255      36184.687      36184.687     -730.42497     -730.42497    
     20000  -14808.471     -14808.471     -14872.153     -14872.153      246.45869      246.45869      36181.586      36181.586     -697.51012     -697.51012    
Loop time of 23.1808 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.727 ns/day, 6.439 hours/ns, 43.139 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.101     | 23.101     | 23.101     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01263    | 0.01263    | 0.01263    |   0.0 |  0.05
Output  | 9.4247e-05 | 9.4247e-05 | 9.4247e-05 |   0.0 |  0.00
Modify  | 0.062194   | 0.062194   | 0.062194   |   0.0 |  0.27
Other   |            | 0.00502    |            |       |  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:       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 = 253.488630887735, Press = 3.44692927590697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14808.471     -14808.471     -14872.153     -14872.153      246.45869      246.45869      36181.586      36181.586     -697.51012     -697.51012    
     21000  -14803.263     -14803.263     -14870.786     -14870.786      261.32286      261.32286      36121.724      36121.724      2785.2001      2785.2001    
Loop time of 23.0714 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.745 ns/day, 6.409 hours/ns, 43.344 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 22.992     | 22.992     | 22.992     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012499   | 0.012499   | 0.012499   |   0.0 |  0.05
Output  | 4.0476e-05 | 4.0476e-05 | 4.0476e-05 |   0.0 |  0.00
Modify  | 0.061813   | 0.061813   | 0.061813   |   0.0 |  0.27
Other   |            | 0.004954   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3381 ave        3381 max        3381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 253.556850829177, Press = 3.25613223675701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14803.263     -14803.263     -14870.786     -14870.786      261.32286      261.32286      36121.724      36121.724      2785.2001      2785.2001    
     22000  -14808.502     -14808.502     -14874.323     -14874.323      254.73627      254.73627      36166.213      36166.213      2.0047309      2.0047309    
Loop time of 23.0241 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.753 ns/day, 6.396 hours/ns, 43.433 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    | 22.944     | 22.944     | 22.944     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012632   | 0.012632   | 0.012632   |   0.0 |  0.05
Output  | 8.1563e-05 | 8.1563e-05 | 8.1563e-05 |   0.0 |  0.00
Modify  | 0.061986   | 0.061986   | 0.061986   |   0.0 |  0.27
Other   |            | 0.004944   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3398 ave        3398 max        3398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121232 ave      121232 max      121232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121232
Ave neighs/atom = 60.616
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.63397039302, Press = -0.725722689221591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14808.502     -14808.502     -14874.323     -14874.323      254.73627      254.73627      36166.213      36166.213      2.0047309      2.0047309    
     23000  -14806.611     -14806.611     -14871.558     -14871.558      251.35354      251.35354      36189.456      36189.456     -1043.4488     -1043.4488    
Loop time of 23.1497 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.732 ns/day, 6.430 hours/ns, 43.197 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.07      | 23.07      | 23.07      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012535   | 0.012535   | 0.012535   |   0.0 |  0.05
Output  | 3.9955e-05 | 3.9955e-05 | 3.9955e-05 |   0.0 |  0.00
Modify  | 0.06198    | 0.06198    | 0.06198    |   0.0 |  0.27
Other   |            | 0.004946   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3377 ave        3377 max        3377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121038 ave      121038 max      121038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121038
Ave neighs/atom = 60.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.660546786021, Press = 1.71824544112255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.611     -14806.611     -14871.558     -14871.558      251.35354      251.35354      36189.456      36189.456     -1043.4488     -1043.4488    
     24000  -14811.028     -14811.028     -14872.443     -14872.443      237.68486      237.68486      36149.927      36149.927      896.76983      896.76983    
Loop time of 23.0862 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.742 ns/day, 6.413 hours/ns, 43.316 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.006     | 23.006     | 23.006     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01277    | 0.01277    | 0.01277    |   0.0 |  0.06
Output  | 7.3457e-05 | 7.3457e-05 | 7.3457e-05 |   0.0 |  0.00
Modify  | 0.062516   | 0.062516   | 0.062516   |   0.0 |  0.27
Other   |            | 0.005057   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3373 ave        3373 max        3373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 253.571244527735, Press = 2.30236179157088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14811.028     -14811.028     -14872.443     -14872.443      237.68486      237.68486      36149.927      36149.927      896.76983      896.76983    
     25000  -14806.107     -14806.107     -14871.835     -14871.835      254.37472      254.37472      36152.215      36152.215      986.09144      986.09144    
Loop time of 23.1601 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.731 ns/day, 6.433 hours/ns, 43.178 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.08      | 23.08      | 23.08      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012857   | 0.012857   | 0.012857   |   0.0 |  0.06
Output  | 3.5476e-05 | 3.5476e-05 | 3.5476e-05 |   0.0 |  0.00
Modify  | 0.062524   | 0.062524   | 0.062524   |   0.0 |  0.27
Other   |            | 0.005093   |            |       |  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:       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 = 253.500894686917, Press = 0.759850081723514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.107     -14806.107     -14871.835     -14871.835      254.37472      254.37472      36152.215      36152.215      986.09144      986.09144    
     26000  -14808.267     -14808.267     -14873.064     -14873.064      250.77032      250.77032      36213.554      36213.554     -2433.7064     -2433.7064    
Loop time of 23.1143 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.738 ns/day, 6.421 hours/ns, 43.263 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.034     | 23.034     | 23.034     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012631   | 0.012631   | 0.012631   |   0.0 |  0.05
Output  | 3.8382e-05 | 3.8382e-05 | 3.8382e-05 |   0.0 |  0.00
Modify  | 0.062423   | 0.062423   | 0.062423   |   0.0 |  0.27
Other   |            | 0.005075   |            |       |  0.02

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

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.522929462114, Press = 0.33890009930862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14808.267     -14808.267     -14873.064     -14873.064      250.77032      250.77032      36213.554      36213.554     -2433.7064     -2433.7064    
     27000  -14807.203     -14807.203     -14872.04      -14872.04       250.92504      250.92504      36176.842      36176.842     -392.25224     -392.25224    
Loop time of 22.9115 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.771 ns/day, 6.364 hours/ns, 43.646 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    | 22.833     | 22.833     | 22.833     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012168   | 0.012168   | 0.012168   |   0.0 |  0.05
Output  | 2.8904e-05 | 2.8904e-05 | 2.8904e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.27
Other   |            | 0.004896   |            |       |  0.02

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

Total # of neighbors = 120858
Ave neighs/atom = 60.429
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.489837763053, Press = 4.11382278867257
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14807.203     -14807.203     -14872.04      -14872.04       250.92504      250.92504      36176.842      36176.842     -392.25224     -392.25224    
     28000  -14811.041     -14811.041     -14876.256     -14876.256      252.38626      252.38626      36123.21       36123.21       2114.5084      2114.5084    
Loop time of 23.0089 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.755 ns/day, 6.391 hours/ns, 43.462 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    | 22.929     | 22.929     | 22.929     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012483   | 0.012483   | 0.012483   |   0.0 |  0.05
Output  | 3.1759e-05 | 3.1759e-05 | 3.1759e-05 |   0.0 |  0.00
Modify  | 0.061926   | 0.061926   | 0.061926   |   0.0 |  0.27
Other   |            | 0.004987   |            |       |  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:       121054 ave      121054 max      121054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 3.747 ns/day, 6.405 hours/ns, 43.372 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    | 22.977     | 22.977     | 22.977     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01254    | 0.01254    | 0.01254    |   0.0 |  0.05
Output  | 4.4784e-05 | 4.4784e-05 | 4.4784e-05 |   0.0 |  0.00
Modify  | 0.061938   | 0.061938   | 0.061938   |   0.0 |  0.27
Other   |            | 0.004984   |            |       |  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:       121140 ave      121140 max      121140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121140
Ave neighs/atom = 60.57
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.399713102361, Press = 0.0848320457014916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14808.817     -14808.817     -14874.71      -14874.71       255.01196      255.01196      36171.911      36171.911     -328.62734     -328.62734    
     30000  -14806.225     -14806.225     -14872.323     -14872.323      255.80523      255.80523      36201.262      36201.262     -1631.5911     -1631.5911    
Loop time of 23.1171 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.737 ns/day, 6.421 hours/ns, 43.258 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.037     | 23.037     | 23.037     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012542   | 0.012542   | 0.012542   |   0.0 |  0.05
Output  | 9.4958e-05 | 9.4958e-05 | 9.4958e-05 |   0.0 |  0.00
Modify  | 0.062071   | 0.062071   | 0.062071   |   0.0 |  0.27
Other   |            | 0.004974   |            |       |  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:       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 = 253.367350683398, Press = 1.43166357229431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14806.225     -14806.225     -14872.323     -14872.323      255.80523      255.80523      36201.262      36201.262     -1631.5911     -1631.5911    
     31000  -14812.507     -14812.507     -14875.47      -14875.47       243.67503      243.67503      36148.862      36148.862      772.69808      772.69808    
Loop time of 22.9508 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.765 ns/day, 6.375 hours/ns, 43.571 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    | 22.872     | 22.872     | 22.872     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012468   | 0.012468   | 0.012468   |   0.0 |  0.05
Output  | 6.5021e-05 | 6.5021e-05 | 6.5021e-05 |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.27
Other   |            | 0.004986   |            |       |  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:       120840 ave      120840 max      120840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120840
Ave neighs/atom = 60.42
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.327595955392, Press = 2.96975335402124
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14812.507     -14812.507     -14875.47      -14875.47       243.67503      243.67503      36148.862      36148.862      772.69808      772.69808    
     32000  -14805.769     -14805.769     -14871.988     -14871.988      256.2746       256.2746       36108.225      36108.225      3408.4072      3408.4072    
Loop time of 23.0785 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.744 ns/day, 6.411 hours/ns, 43.330 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 22.998     | 22.998     | 22.998     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012687   | 0.012687   | 0.012687   |   0.0 |  0.05
Output  | 7.7415e-05 | 7.7415e-05 | 7.7415e-05 |   0.0 |  0.00
Modify  | 0.06234    | 0.06234    | 0.06234    |   0.0 |  0.27
Other   |            | 0.005023   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3352 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 253.273872243172, Press = 0.405356479747581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -14805.769     -14805.769     -14871.988     -14871.988      256.2746       256.2746       36108.225      36108.225      3408.4072      3408.4072    
     33000  -14808.912     -14808.912     -14873.049     -14873.049      248.21523      248.21523      36193.464      36193.464     -1403.9531     -1403.9531    
Loop time of 23.0466 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.749 ns/day, 6.402 hours/ns, 43.390 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    | 22.967     | 22.967     | 22.967     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.012599   | 0.012599   | 0.012599   |   0.0 |  0.05
Output  | 3.167e-05  | 3.167e-05  | 3.167e-05  |   0.0 |  0.00
Modify  | 0.06196    | 0.06196    | 0.06196    |   0.0 |  0.27
Other   |            | 0.005064   |            |       |  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:       121348 ave      121348 max      121348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121348
Ave neighs/atom = 60.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
36168.554403247

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0