# 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.532111041247845*${_u_distance}
variable latticeconst_converted equal 3.532111041247845*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.53211104124785
Lattice spacing in x,y,z = 3.532111 3.532111 3.532111
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.32111 35.32111 35.32111)
  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 (35.32111 35.32111 35.32111)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimJungLee_2012_LiMg__MO_427397414195_002
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 44065.9406253475 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_427397414195_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3231.3671     -3231.3671     -3296.7787     -3296.7787      253.15         253.15         44065.941      44065.941      1585.5199      1585.5199    
      1000  -3156.1398     -3156.1398     -3225.1209     -3225.1209      266.96392      266.96392      44376.047      44376.047      107.26964      107.26964    
Loop time of 189.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.457 ns/day, 52.512 hours/ns, 5.290 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.13     | 188.13     | 188.13     |   0.0 | 99.52
Neigh   | 0.38485    | 0.38485    | 0.38485    |   0.0 |  0.20
Comm    | 0.093807   | 0.093807   | 0.093807   |   0.0 |  0.05
Output  | 0.00022318 | 0.00022318 | 0.00022318 |   0.0 |  0.00
Modify  | 0.37636    | 0.37636    | 0.37636    |   0.0 |  0.20
Other   |            | 0.05723    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3313 ave        3313 max        3313 min
Histogram: 1 0 0 0 0 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 = 17
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3156.1398     -3156.1398     -3225.1209     -3225.1209      266.96392      266.96392      44376.047      44376.047      107.26964      107.26964    
      2000  -3162.6248     -3162.6248     -3226.6085     -3226.6085      247.62377      247.62377      44280.852      44280.852      191.00014      191.00014    
Loop time of 204.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.938 hours/ns, 4.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.93     | 203.93     | 203.93     |   0.0 | 99.49
Neigh   | 0.47268    | 0.47268    | 0.47268    |   0.0 |  0.23
Comm    | 0.10109    | 0.10109    | 0.10109    |   0.0 |  0.05
Output  | 0.00021469 | 0.00021469 | 0.00021469 |   0.0 |  0.00
Modify  | 0.41521    | 0.41521    | 0.41521    |   0.0 |  0.20
Other   |            | 0.06108    |            |       |  0.03

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

Total # of neighbors = 121034
Ave neighs/atom = 60.517
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
      2000  -3162.6248     -3162.6248     -3226.6085     -3226.6085      247.62377      247.62377      44280.852      44280.852      191.00014      191.00014    
      3000  -3157.0769     -3157.0769     -3224.7013     -3224.7013      261.71358      261.71358      44539.765      44539.765     -313.5942      -313.5942     
Loop time of 205.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.182 hours/ns, 4.858 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    | 204.8      | 204.8      | 204.8      |   0.0 | 99.49
Neigh   | 0.47764    | 0.47764    | 0.47764    |   0.0 |  0.23
Comm    | 0.10238    | 0.10238    | 0.10238    |   0.0 |  0.05
Output  | 0.00025797 | 0.00025797 | 0.00025797 |   0.0 |  0.00
Modify  | 0.41418    | 0.41418    | 0.41418    |   0.0 |  0.20
Other   |            | 0.06053    |            |       |  0.03

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

Total # of neighbors = 120862
Ave neighs/atom = 60.431
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3157.0769     -3157.0769     -3224.7013     -3224.7013      261.71358      261.71358      44539.765      44539.765     -313.5942      -313.5942     
      4000  -3161.8119     -3161.8119     -3225.6772     -3225.6772      247.16522      247.16522      44264.072      44264.072      257.59289      257.59289    
Loop time of 205.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.208 hours/ns, 4.856 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    | 204.89     | 204.89     | 204.89     |   0.0 | 99.49
Neigh   | 0.47374    | 0.47374    | 0.47374    |   0.0 |  0.23
Comm    | 0.10252    | 0.10252    | 0.10252    |   0.0 |  0.05
Output  | 0.00020746 | 0.00020746 | 0.00020746 |   0.0 |  0.00
Modify  | 0.41948    | 0.41948    | 0.41948    |   0.0 |  0.20
Other   |            | 0.06086    |            |       |  0.03

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:       120964 ave      120964 max      120964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120964
Ave neighs/atom = 60.482
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3161.8119     -3161.8119     -3225.6772     -3225.6772      247.16522      247.16522      44264.072      44264.072      257.59289      257.59289    
      5000  -3158.67       -3158.67       -3224.1998     -3224.1998      253.60685      253.60685      44534.749      44534.749     -301.63495     -301.63495    
Loop time of 193.007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.448 ns/day, 53.613 hours/ns, 5.181 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.01     | 192.01     | 192.01     |   0.0 | 99.48
Neigh   | 0.4583     | 0.4583     | 0.4583     |   0.0 |  0.24
Comm    | 0.096489   | 0.096489   | 0.096489   |   0.0 |  0.05
Output  | 0.00016626 | 0.00016626 | 0.00016626 |   0.0 |  0.00
Modify  | 0.38574    | 0.38574    | 0.38574    |   0.0 |  0.20
Other   |            | 0.05804    |            |       |  0.03

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

Total # of neighbors = 120802
Ave neighs/atom = 60.401
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 258.001688214263, Press = -118.593297378888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
      5000  -3158.67       -3158.67       -3224.1998     -3224.1998      253.60685      253.60685      44534.749      44534.749     -301.63495     -301.63495    
      6000  -3159.4253     -3159.4253     -3225.2311     -3225.2311      254.67553      254.67553      44398.265      44398.265     -46.728159     -46.728159    
Loop time of 174.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.516 hours/ns, 5.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.7      | 173.7      | 173.7      |   0.0 | 99.45
Neigh   | 0.4547     | 0.4547     | 0.4547     |   0.0 |  0.26
Comm    | 0.08916    | 0.08916    | 0.08916    |   0.0 |  0.05
Output  | 0.00016943 | 0.00016943 | 0.00016943 |   0.0 |  0.00
Modify  | 0.35449    | 0.35449    | 0.35449    |   0.0 |  0.20
Other   |            | 0.05463    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3331 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.891638628911, Press = -51.7470700520682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3159.4253     -3159.4253     -3225.2311     -3225.2311      254.67553      254.67553      44398.265      44398.265     -46.728159     -46.728159    
      7000  -3159.8417     -3159.8417     -3225.7664     -3225.7664      255.13542      255.13542      44273.369      44273.369      241.86056      241.86056    
Loop time of 174.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.575 hours/ns, 5.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.9      | 173.9      | 173.9      |   0.0 | 99.44
Neigh   | 0.47594    | 0.47594    | 0.47594    |   0.0 |  0.27
Comm    | 0.089192   | 0.089192   | 0.089192   |   0.0 |  0.05
Output  | 0.00016771 | 0.00016771 | 0.00016771 |   0.0 |  0.00
Modify  | 0.35412    | 0.35412    | 0.35412    |   0.0 |  0.20
Other   |            | 0.05445    |            |       |  0.03

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

Total # of neighbors = 121012
Ave neighs/atom = 60.506
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.463420828172, Press = -3.53565977313779
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3159.8417     -3159.8417     -3225.7664     -3225.7664      255.13542      255.13542      44273.369      44273.369      241.86056      241.86056    
      8000  -3155.9792     -3155.9792     -3223.1753     -3223.1753      260.05556      260.05556      44761.958      44761.958     -849.5963      -849.5963     
Loop time of 174.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.574 hours/ns, 5.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.94     | 173.94     | 173.94     |   0.0 | 99.47
Neigh   | 0.43271    | 0.43271    | 0.43271    |   0.0 |  0.25
Comm    | 0.088876   | 0.088876   | 0.088876   |   0.0 |  0.05
Output  | 0.00016728 | 0.00016728 | 0.00016728 |   0.0 |  0.00
Modify  | 0.35339    | 0.35339    | 0.35339    |   0.0 |  0.20
Other   |            | 0.05481    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3287 ave        3287 max        3287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120700 ave      120700 max      120700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120700
Ave neighs/atom = 60.35
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406533889791, Press = -10.5118268678313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
      8000  -3155.9792     -3155.9792     -3223.1753     -3223.1753      260.05556      260.05556      44761.958      44761.958     -849.5963      -849.5963     
      9000  -3155.7805     -3155.7805     -3222.9822     -3222.9822      260.07742      260.07742      44197.705      44197.705      605.58682      605.58682    
Loop time of 174.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.556 hours/ns, 5.721 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.85     | 173.85     | 173.85     |   0.0 | 99.45
Neigh   | 0.45549    | 0.45549    | 0.45549    |   0.0 |  0.26
Comm    | 0.089578   | 0.089578   | 0.089578   |   0.0 |  0.05
Output  | 0.0001675  | 0.0001675  | 0.0001675  |   0.0 |  0.00
Modify  | 0.3541     | 0.3541     | 0.3541     |   0.0 |  0.20
Other   |            | 0.05434    |            |       |  0.03

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:       121278 ave      121278 max      121278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121278
Ave neighs/atom = 60.639
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.046367787068, Press = -10.1528057245175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3155.7805     -3155.7805     -3222.9822     -3222.9822      260.07742      260.07742      44197.705      44197.705      605.58682      605.58682    
     10000  -3160.3328     -3160.3328     -3225.9027     -3225.9027      253.76211      253.76211      44405.156      44405.156     -125.49139     -125.49139    
Loop time of 178.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.484 ns/day, 49.587 hours/ns, 5.602 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.54     | 177.54     | 177.54     |   0.0 | 99.46
Neigh   | 0.46122    | 0.46122    | 0.46122    |   0.0 |  0.26
Comm    | 0.091052   | 0.091052   | 0.091052   |   0.0 |  0.05
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.36294    | 0.36294    | 0.36294    |   0.0 |  0.20
Other   |            | 0.05457    |            |       |  0.03

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

Total # of neighbors = 121082
Ave neighs/atom = 60.541
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.966413223431, Press = 0.690210315357157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.3328     -3160.3328     -3225.9027     -3225.9027      253.76211      253.76211      44405.156      44405.156     -125.49139     -125.49139    
     11000  -3160.5394     -3160.5394     -3226.4813     -3226.4813      255.20179      255.20179      44450.264      44450.264     -218.78164     -218.78164    
Loop time of 176.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.490 ns/day, 48.968 hours/ns, 5.673 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.35     | 175.35     | 175.35     |   0.0 | 99.47
Neigh   | 0.4367     | 0.4367     | 0.4367     |   0.0 |  0.25
Comm    | 0.0903     | 0.0903     | 0.0903     |   0.0 |  0.05
Output  | 0.00016833 | 0.00016833 | 0.00016833 |   0.0 |  0.00
Modify  | 0.35714    | 0.35714    | 0.35714    |   0.0 |  0.20
Other   |            | 0.05386    |            |       |  0.03

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:       120842 ave      120842 max      120842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120842
Ave neighs/atom = 60.421
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.107379656469, Press = -6.00119009241993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.5394     -3160.5394     -3226.4813     -3226.4813      255.20179      255.20179      44450.264      44450.264     -218.78164     -218.78164    
     12000  -3157.423      -3157.423      -3224.5051     -3224.5051      259.61456      259.61456      44277.368      44277.368      363.83177      363.83177    
Loop time of 181.113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.309 hours/ns, 5.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.11     | 180.11     | 180.11     |   0.0 | 99.44
Neigh   | 0.48576    | 0.48576    | 0.48576    |   0.0 |  0.27
Comm    | 0.093229   | 0.093229   | 0.093229   |   0.0 |  0.05
Output  | 0.00016649 | 0.00016649 | 0.00016649 |   0.0 |  0.00
Modify  | 0.37178    | 0.37178    | 0.37178    |   0.0 |  0.21
Other   |            | 0.05519    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3323 ave        3323 max        3323 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121206 ave      121206 max      121206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121206
Ave neighs/atom = 60.603
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.037110946581, Press = -0.718229074470963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3157.423      -3157.423      -3224.5051     -3224.5051      259.61456      259.61456      44277.368      44277.368      363.83177      363.83177    
     13000  -3160.9018     -3160.9018     -3226.3032     -3226.3032      253.11035      253.11035      44416.058      44416.058     -168.76423     -168.76423    
Loop time of 186.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.463 ns/day, 51.837 hours/ns, 5.359 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.63     | 185.63     | 185.63     |   0.0 | 99.47
Neigh   | 0.44677    | 0.44677    | 0.44677    |   0.0 |  0.24
Comm    | 0.093297   | 0.093297   | 0.093297   |   0.0 |  0.05
Output  | 0.0001675  | 0.0001675  | 0.0001675  |   0.0 |  0.00
Modify  | 0.38803    | 0.38803    | 0.38803    |   0.0 |  0.21
Other   |            | 0.05739    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3302 ave        3302 max        3302 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120942 ave      120942 max      120942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120942
Ave neighs/atom = 60.471
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.900464162389, Press = -2.69098630805689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     13000  -3160.9018     -3160.9018     -3226.3032     -3226.3032      253.11035      253.11035      44416.058      44416.058     -168.76423     -168.76423    
     14000  -3156.3734     -3156.3734     -3224.0454     -3224.0454      261.89791      261.89791      44227.328      44227.328      496.63601      496.63601    
Loop time of 183.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.472 ns/day, 50.869 hours/ns, 5.461 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 182.13     | 182.13     | 182.13     |   0.0 | 99.46
Neigh   | 0.46694    | 0.46694    | 0.46694    |   0.0 |  0.25
Comm    | 0.093453   | 0.093453   | 0.093453   |   0.0 |  0.05
Output  | 0.00047167 | 0.00047167 | 0.00047167 |   0.0 |  0.00
Modify  | 0.37829    | 0.37829    | 0.37829    |   0.0 |  0.21
Other   |            | 0.05636    |            |       |  0.03

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:       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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.973425955347, Press = -1.20474613901227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3156.3734     -3156.3734     -3224.0454     -3224.0454      261.89791      261.89791      44227.328      44227.328      496.63601      496.63601    
     15000  -3158.8411     -3158.8411     -3224.3632     -3224.3632      253.57752      253.57752      44688.128      44688.128     -796.42556     -796.42556    
Loop time of 191.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.451 ns/day, 53.266 hours/ns, 5.215 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.74     | 190.74     | 190.74     |   0.0 | 99.47
Neigh   | 0.4569     | 0.4569     | 0.4569     |   0.0 |  0.24
Comm    | 0.096028   | 0.096028   | 0.096028   |   0.0 |  0.05
Output  | 0.00016866 | 0.00016866 | 0.00016866 |   0.0 |  0.00
Modify  | 0.40563    | 0.40563    | 0.40563    |   0.0 |  0.21
Other   |            | 0.05866    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120832 ave      120832 max      120832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120832
Ave neighs/atom = 60.416
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.767014305397, Press = 0.747832288361095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     15000  -3158.8411     -3158.8411     -3224.3632     -3224.3632      253.57752      253.57752      44688.128      44688.128     -796.42556     -796.42556    
     16000  -3159.482      -3159.482      -3224.8092     -3224.8092      252.82288      252.82288      44274.831      44274.831      287.86293      287.86293    
Loop time of 202.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.310 hours/ns, 4.933 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.63     | 201.63     | 201.63     |   0.0 | 99.46
Neigh   | 0.49146    | 0.49146    | 0.49146    |   0.0 |  0.24
Comm    | 0.1011     | 0.1011     | 0.1011     |   0.0 |  0.05
Output  | 0.0001694  | 0.0001694  | 0.0001694  |   0.0 |  0.00
Modify  | 0.43419    | 0.43419    | 0.43419    |   0.0 |  0.21
Other   |            | 0.06012    |            |       |  0.03

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:       121194 ave      121194 max      121194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121194
Ave neighs/atom = 60.597
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.549165727994, Press = -3.25056441624846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3159.482      -3159.482      -3224.8092     -3224.8092      252.82288      252.82288      44274.831      44274.831      287.86293      287.86293    
     17000  -3160.5944     -3160.5944     -3225.134      -3225.134       249.7749       249.7749       44378.269      44378.269      12.764893      12.764893    
Loop time of 204.165 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.712 hours/ns, 4.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.09     | 203.09     | 203.09     |   0.0 | 99.47
Neigh   | 0.46877    | 0.46877    | 0.46877    |   0.0 |  0.23
Comm    | 0.10209    | 0.10209    | 0.10209    |   0.0 |  0.05
Output  | 0.00025103 | 0.00025103 | 0.00025103 |   0.0 |  0.00
Modify  | 0.44077    | 0.44077    | 0.44077    |   0.0 |  0.22
Other   |            | 0.06117    |            |       |  0.03

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:       120972 ave      120972 max      120972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120972
Ave neighs/atom = 60.486
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.565946073473, Press = 1.85729222182555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     17000  -3160.5944     -3160.5944     -3225.134      -3225.134       249.7749       249.7749       44378.269      44378.269      12.764893      12.764893    
     18000  -3157.6476     -3157.6476     -3224.2533     -3224.2533      257.77077      257.77077      44492.292      44492.292     -203.39683     -203.39683    
Loop time of 180.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.105 hours/ns, 5.544 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.41     | 179.41     | 179.41     |   0.0 | 99.47
Neigh   | 0.44374    | 0.44374    | 0.44374    |   0.0 |  0.25
Comm    | 0.091419   | 0.091419   | 0.091419   |   0.0 |  0.05
Output  | 0.00016517 | 0.00016517 | 0.00016517 |   0.0 |  0.00
Modify  | 0.37207    | 0.37207    | 0.37207    |   0.0 |  0.21
Other   |            | 0.05625    |            |       |  0.03

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

Total # of neighbors = 120928
Ave neighs/atom = 60.464
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.73238241132, Press = -2.07876253931134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3157.6476     -3157.6476     -3224.2533     -3224.2533      257.77077      257.77077      44492.292      44492.292     -203.39683     -203.39683    
     19000  -3160.4476     -3160.4476     -3226.6669     -3226.6669      256.27554      256.27554      44319.357      44319.357      8.1579625      8.1579625    
Loop time of 193.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.693 hours/ns, 5.173 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.25     | 192.25     | 192.25     |   0.0 | 99.46
Neigh   | 0.48233    | 0.48233    | 0.48233    |   0.0 |  0.25
Comm    | 0.097676   | 0.097676   | 0.097676   |   0.0 |  0.05
Output  | 0.00016603 | 0.00016603 | 0.00016603 |   0.0 |  0.00
Modify  | 0.40928    | 0.40928    | 0.40928    |   0.0 |  0.21
Other   |            | 0.05797    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3370 ave        3370 max        3370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.714159887599, Press = -0.713194507716274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.4476     -3160.4476     -3226.6669     -3226.6669      256.27554      256.27554      44319.357      44319.357      8.1579625      8.1579625    
     20000  -3162.117      -3162.117      -3226.6247     -3226.6247      249.65145      249.65145      44315.383      44315.383      44.295268      44.295268    
Loop time of 179.91 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.975 hours/ns, 5.558 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.93     | 178.93     | 178.93     |   0.0 | 99.46
Neigh   | 0.46315    | 0.46315    | 0.46315    |   0.0 |  0.26
Comm    | 0.092125   | 0.092125   | 0.092125   |   0.0 |  0.05
Output  | 0.00016624 | 0.00016624 | 0.00016624 |   0.0 |  0.00
Modify  | 0.36851    | 0.36851    | 0.36851    |   0.0 |  0.20
Other   |            | 0.05553    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3310 ave        3310 max        3310 min
Histogram: 1 0 0 0 0 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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.747422663997, Press = 0.439524261314872
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3162.117      -3162.117      -3226.6247     -3226.6247      249.65145      249.65145      44315.383      44315.383      44.295268      44.295268    
     21000  -3157.6746     -3157.6746     -3223.5717     -3223.5717      255.02885      255.02885      44521.906      44521.906     -273.06672     -273.06672    
Loop time of 175.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.710 hours/ns, 5.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.42     | 174.42     | 174.42     |   0.0 | 99.47
Neigh   | 0.43314    | 0.43314    | 0.43314    |   0.0 |  0.25
Comm    | 0.089558   | 0.089558   | 0.089558   |   0.0 |  0.05
Output  | 0.00020248 | 0.00020248 | 0.00020248 |   0.0 |  0.00
Modify  | 0.3575     | 0.3575     | 0.3575     |   0.0 |  0.20
Other   |            | 0.05483    |            |       |  0.03

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

Total # of neighbors = 120898
Ave neighs/atom = 60.449
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.633590655779, Press = -2.16723721108076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     21000  -3157.6746     -3157.6746     -3223.5717     -3223.5717      255.02885      255.02885      44521.906      44521.906     -273.06672     -273.06672    
     22000  -3162.9822     -3162.9822     -3227.3877     -3227.3877      249.25582      249.25582      44123.287      44123.287      639.78872      639.78872    
Loop time of 200.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.557 hours/ns, 5.000 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    | 198.95     | 198.95     | 198.95     |   0.0 | 99.47
Neigh   | 0.46759    | 0.46759    | 0.46759    |   0.0 |  0.23
Comm    | 0.10051    | 0.10051    | 0.10051    |   0.0 |  0.05
Output  | 0.00023474 | 0.00023474 | 0.00023474 |   0.0 |  0.00
Modify  | 0.42682    | 0.42682    | 0.42682    |   0.0 |  0.21
Other   |            | 0.05968    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507322275174, Press = -0.615688946122761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3162.9822     -3162.9822     -3227.3877     -3227.3877      249.25582      249.25582      44123.287      44123.287      639.78872      639.78872    
     23000  -3159.425      -3159.425      -3225.801      -3225.801       256.88179      256.88179      44534.172      44534.172     -420.42424     -420.42424    
Loop time of 205.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 57.037 hours/ns, 4.870 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.23     | 204.23     | 204.23     |   0.0 | 99.46
Neigh   | 0.49502    | 0.49502    | 0.49502    |   0.0 |  0.24
Comm    | 0.10259    | 0.10259    | 0.10259    |   0.0 |  0.05
Output  | 0.00017046 | 0.00017046 | 0.00017046 |   0.0 |  0.00
Modify  | 0.44604    | 0.44604    | 0.44604    |   0.0 |  0.22
Other   |            | 0.06135    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3324 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120838 ave      120838 max      120838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120838
Ave neighs/atom = 60.419
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.429299112546, Press = -0.160020989016747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     23000  -3159.425      -3159.425      -3225.801      -3225.801       256.88179      256.88179      44534.172      44534.172     -420.42424     -420.42424    
     24000  -3160.4299     -3160.4299     -3226.0205     -3226.0205      253.84212      253.84212      44259.126      44259.126      292.99753      292.99753    
Loop time of 203.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.611 hours/ns, 4.907 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.72     | 202.72     | 202.72     |   0.0 | 99.47
Neigh   | 0.47112    | 0.47112    | 0.47112    |   0.0 |  0.23
Comm    | 0.10267    | 0.10267    | 0.10267    |   0.0 |  0.05
Output  | 0.00017159 | 0.00017159 | 0.00017159 |   0.0 |  0.00
Modify  | 0.44086    | 0.44086    | 0.44086    |   0.0 |  0.22
Other   |            | 0.06077    |            |       |  0.03

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:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.410167532016, Press = -2.50286700065413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.4299     -3160.4299     -3226.0205     -3226.0205      253.84212      253.84212      44259.126      44259.126      292.99753      292.99753    
     25000  -3161.491      -3161.491      -3226.2291     -3226.2291      250.5429       250.5429       44350.764      44350.764      17.393608      17.393608    
Loop time of 205.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 57.019 hours/ns, 4.872 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.16     | 204.16     | 204.16     |   0.0 | 99.46
Neigh   | 0.49503    | 0.49503    | 0.49503    |   0.0 |  0.24
Comm    | 0.10239    | 0.10239    | 0.10239    |   0.0 |  0.05
Output  | 0.00021836 | 0.00021836 | 0.00021836 |   0.0 |  0.00
Modify  | 0.4458     | 0.4458     | 0.4458     |   0.0 |  0.22
Other   |            | 0.061      |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3274 ave        3274 max        3274 min
Histogram: 1 0 0 0 0 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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.303048280045, Press = -0.454298510525136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     25000  -3161.491      -3161.491      -3226.2291     -3226.2291      250.5429       250.5429       44350.764      44350.764      17.393608      17.393608    
     26000  -3159.0372     -3159.0372     -3223.2134     -3223.2134      248.36834      248.36834      44376.037      44376.037      60.891043      60.891043    
Loop time of 205.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.984 hours/ns, 4.875 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.06     | 204.06     | 204.06     |   0.0 | 99.47
Neigh   | 0.47409    | 0.47409    | 0.47409    |   0.0 |  0.23
Comm    | 0.10238    | 0.10238    | 0.10238    |   0.0 |  0.05
Output  | 0.00026385 | 0.00026385 | 0.00026385 |   0.0 |  0.00
Modify  | 0.44582    | 0.44582    | 0.44582    |   0.0 |  0.22
Other   |            | 0.06063    |            |       |  0.03

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:       120906 ave      120906 max      120906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120906
Ave neighs/atom = 60.453
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.310350944641, Press = -1.22022114407577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3159.0372     -3159.0372     -3223.2134     -3223.2134      248.36834      248.36834      44376.037      44376.037      60.891043      60.891043    
     27000  -3160.4936     -3160.4936     -3226.3116     -3226.3116      254.72269      254.72269      44308.702      44308.702      112.80428      112.80428    
Loop time of 205.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.076 hours/ns, 4.867 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.37     | 204.37     | 204.37     |   0.0 | 99.46
Neigh   | 0.49671    | 0.49671    | 0.49671    |   0.0 |  0.24
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.05
Output  | 0.00021647 | 0.00021647 | 0.00021647 |   0.0 |  0.00
Modify  | 0.44082    | 0.44082    | 0.44082    |   0.0 |  0.21
Other   |            | 0.06076    |            |       |  0.03

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

Total # of neighbors = 120994
Ave neighs/atom = 60.497
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.30170756138, Press = 0.202741772524302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     27000  -3160.4936     -3160.4936     -3226.3116     -3226.3116      254.72269      254.72269      44308.702      44308.702      112.80428      112.80428    
     28000  -3160.0806     -3160.0806     -3225.3046     -3225.3046      252.42375      252.42375      44614.131      44614.131     -624.17475     -624.17475    
Loop time of 194.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.445 ns/day, 53.970 hours/ns, 5.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.22     | 193.22     | 193.22     |   0.0 | 99.45
Neigh   | 0.50359    | 0.50359    | 0.50359    |   0.0 |  0.26
Comm    | 0.098418   | 0.098418   | 0.098418   |   0.0 |  0.05
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.41344    | 0.41344    | 0.41344    |   0.0 |  0.21
Other   |            | 0.05873    |            |       |  0.03

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:       120746 ave      120746 max      120746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120746
Ave neighs/atom = 60.373
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.202330469412, Press = -1.46447447074957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.0806     -3160.0806     -3225.3046     -3225.3046      252.42375      252.42375      44614.131      44614.131     -624.17475     -624.17475    
     29000  -3156.8938     -3156.8938     -3223.9984     -3223.9984      259.70147      259.70147      44110.233      44110.233      814.75283      814.75283    
Loop time of 175.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.614 hours/ns, 5.714 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.05     | 174.05     | 174.05     |   0.0 | 99.45
Neigh   | 0.45587    | 0.45587    | 0.45587    |   0.0 |  0.26
Comm    | 0.089844   | 0.089844   | 0.089844   |   0.0 |  0.05
Output  | 0.00021064 | 0.00021064 | 0.00021064 |   0.0 |  0.00
Modify  | 0.35772    | 0.35772    | 0.35772    |   0.0 |  0.20
Other   |            | 0.05549    |            |       |  0.03

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

Total # of neighbors = 121148
Ave neighs/atom = 60.574
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1979151338, Press = -0.892614310147055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3156.8938     -3156.8938     -3223.9984     -3223.9984      259.70147      259.70147      44110.233      44110.233      814.75283      814.75283    
     30000  -3159.3828     -3159.3828     -3223.5592     -3223.5592      248.36959      248.36959      44473.332      44473.332     -184.68208     -184.68208    
Loop time of 187.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.460 ns/day, 52.136 hours/ns, 5.328 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.7      | 186.7      | 186.7      |   0.0 | 99.47
Neigh   | 0.45024    | 0.45024    | 0.45024    |   0.0 |  0.24
Comm    | 0.094944   | 0.094944   | 0.094944   |   0.0 |  0.05
Output  | 0.00016845 | 0.00016845 | 0.00016845 |   0.0 |  0.00
Modify  | 0.39224    | 0.39224    | 0.39224    |   0.0 |  0.21
Other   |            | 0.05711    |            |       |  0.03

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:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.131992314286, Press = 0.321135518969846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     30000  -3159.3828     -3159.3828     -3223.5592     -3223.5592      248.36959      248.36959      44473.332      44473.332     -184.68208     -184.68208    
     31000  -3160.683      -3160.683      -3226.3138     -3226.3138      253.9978       253.9978       44311.45       44311.45       102.14957      102.14957    
Loop time of 174.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.551 hours/ns, 5.721 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.82     | 173.82     | 173.82     |   0.0 | 99.45
Neigh   | 0.45465    | 0.45465    | 0.45465    |   0.0 |  0.26
Comm    | 0.089975   | 0.089975   | 0.089975   |   0.0 |  0.05
Output  | 0.00016864 | 0.00016864 | 0.00016864 |   0.0 |  0.00
Modify  | 0.3569     | 0.3569     | 0.3569     |   0.0 |  0.20
Other   |            | 0.05595    |            |       |  0.03

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

Total # of neighbors = 121182
Ave neighs/atom = 60.591
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.096290599239, Press = -1.73795351513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.683      -3160.683      -3226.3138     -3226.3138      253.9978       253.9978       44311.45       44311.45       102.14957      102.14957    
     32000  -3159.0756     -3159.0756     -3225.5786     -3225.5786      257.37349      257.37349      44321.109      44321.109      137.90525      137.90525    
Loop time of 204.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.911 hours/ns, 4.881 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    | 203.8      | 203.8      | 203.8      |   0.0 | 99.47
Neigh   | 0.46971    | 0.46971    | 0.46971    |   0.0 |  0.23
Comm    | 0.10323    | 0.10323    | 0.10323    |   0.0 |  0.05
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.44366    | 0.44366    | 0.44366    |   0.0 |  0.22
Other   |            | 0.0606     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.008430505911, Press = 0.39513151852875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     32000  -3159.0756     -3159.0756     -3225.5786     -3225.5786      257.37349      257.37349      44321.109      44321.109      137.90525      137.90525    
     33000  -3160.2737     -3160.2737     -3225.318      -3225.318       251.72816      251.72816      44457.413      44457.413     -243.57291     -243.57291    
Loop time of 204.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.912 hours/ns, 4.881 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    | 203.8      | 203.8      | 203.8      |   0.0 | 99.47
Neigh   | 0.47313    | 0.47313    | 0.47313    |   0.0 |  0.23
Comm    | 0.10283    | 0.10283    | 0.10283    |   0.0 |  0.05
Output  | 0.00021213 | 0.00021213 | 0.00021213 |   0.0 |  0.00
Modify  | 0.44539    | 0.44539    | 0.44539    |   0.0 |  0.22
Other   |            | 0.06128    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3343 ave        3343 max        3343 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012157437765, Press = -0.597869072950581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3160.2737     -3160.2737     -3225.318      -3225.318       251.72816      251.72816      44457.413      44457.413     -243.57291     -243.57291    
     34000  -3158.1399     -3158.1399     -3223.5829     -3223.5829      253.27098      253.27098      44383.93       44383.93       118.41106      118.41106    
Loop time of 204.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.890 hours/ns, 4.883 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    | 203.73     | 203.73     | 203.73     |   0.0 | 99.47
Neigh   | 0.47261    | 0.47261    | 0.47261    |   0.0 |  0.23
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.05
Output  | 0.00017118 | 0.00017118 | 0.00017118 |   0.0 |  0.00
Modify  | 0.44256    | 0.44256    | 0.44256    |   0.0 |  0.22
Other   |            | 0.06057    |            |       |  0.03

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:       121058 ave      121058 max      121058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121058
Ave neighs/atom = 60.529
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.965440886337, Press = -1.4409868961954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3158.1399     -3158.1399     -3223.5829     -3223.5829      253.27098      253.27098      44383.93       44383.93       118.41106      118.41106    
     35000  -3157.9172     -3157.9172     -3224.4358     -3224.4358      257.43394      257.43394      44290.024      44290.024      301.60687      301.60687    
Loop time of 205.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.988 hours/ns, 4.874 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    | 204.07     | 204.07     | 204.07     |   0.0 | 99.47
Neigh   | 0.47415    | 0.47415    | 0.47415    |   0.0 |  0.23
Comm    | 0.10253    | 0.10253    | 0.10253    |   0.0 |  0.05
Output  | 0.00021106 | 0.00021106 | 0.00021106 |   0.0 |  0.00
Modify  | 0.44414    | 0.44414    | 0.44414    |   0.0 |  0.22
Other   |            | 0.06068    |            |       |  0.03

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:       121292 ave      121292 max      121292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121292
Ave neighs/atom = 60.646
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.968958626898, Press = 1.40493887933058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3157.9172     -3157.9172     -3224.4358     -3224.4358      257.43394      257.43394      44290.024      44290.024      301.60687      301.60687    
     36000  -3162.8418     -3162.8418     -3226.5835     -3226.5835      246.68714      246.68714      44496.175      44496.175     -359.87557     -359.87557    
Loop time of 204.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.784 hours/ns, 4.892 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    | 203.31     | 203.31     | 203.31     |   0.0 | 99.46
Neigh   | 0.49679    | 0.49679    | 0.49679    |   0.0 |  0.24
Comm    | 0.10259    | 0.10259    | 0.10259    |   0.0 |  0.05
Output  | 0.00016966 | 0.00016966 | 0.00016966 |   0.0 |  0.00
Modify  | 0.45118    | 0.45118    | 0.45118    |   0.0 |  0.22
Other   |            | 0.06076    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3275 ave        3275 max        3275 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120758 ave      120758 max      120758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120758
Ave neighs/atom = 60.379
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.949764983699, Press = -0.86874281615918
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -3162.8418     -3162.8418     -3226.5835     -3226.5835      246.68714      246.68714      44496.175      44496.175     -359.87557     -359.87557    
     37000  -3159.0724     -3159.0724     -3225.1473     -3225.1473      255.71667      255.71667      44246.019      44246.019      366.44724      366.44724    
Loop time of 201.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.044 hours/ns, 4.956 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.67     | 200.67     | 200.67     |   0.0 | 99.46
Neigh   | 0.49221    | 0.49221    | 0.49221    |   0.0 |  0.24
Comm    | 0.10167    | 0.10167    | 0.10167    |   0.0 |  0.05
Output  | 0.00017183 | 0.00017183 | 0.00017183 |   0.0 |  0.00
Modify  | 0.43727    | 0.43727    | 0.43727    |   0.0 |  0.22
Other   |            | 0.06075    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3261 ave        3261 max        3261 min
Histogram: 1 0 0 0 0 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 = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.919671515504, Press = -0.226132566842831
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     37000  -3159.0724     -3159.0724     -3225.1473     -3225.1473      255.71667      255.71667      44246.019      44246.019      366.44724      366.44724    
     38000  -3158.2049     -3158.2049     -3223.9106     -3223.9106      254.28788      254.28788      44462.872      44462.872     -198.69738     -198.69738    
Loop time of 204.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.679 hours/ns, 4.901 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.97     | 202.97     | 202.97     |   0.0 | 99.47
Neigh   | 0.47209    | 0.47209    | 0.47209    |   0.0 |  0.23
Comm    | 0.10158    | 0.10158    | 0.10158    |   0.0 |  0.05
Output  | 0.00016845 | 0.00016845 | 0.00016845 |   0.0 |  0.00
Modify  | 0.44242    | 0.44242    | 0.44242    |   0.0 |  0.22
Other   |            | 0.06116    |            |       |  0.03

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:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.892794048921, Press = -0.481481596670221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     38000  -3158.2049     -3158.2049     -3223.9106     -3223.9106      254.28788      254.28788      44462.872      44462.872     -198.69738     -198.69738    
     39000  -3160.3181     -3160.3181     -3225.2705     -3225.2705      251.37274      251.37274      44278.748      44278.748      230.98869      230.98869    
Loop time of 204.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.714 hours/ns, 4.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.08     | 203.08     | 203.08     |   0.0 | 99.47
Neigh   | 0.47355    | 0.47355    | 0.47355    |   0.0 |  0.23
Comm    | 0.10328    | 0.10328    | 0.10328    |   0.0 |  0.05
Output  | 0.00016855 | 0.00016855 | 0.00016855 |   0.0 |  0.00
Modify  | 0.44632    | 0.44632    | 0.44632    |   0.0 |  0.22
Other   |            | 0.06105    |            |       |  0.03

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:       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 = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.924541286116, Press = -0.157336674952475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3160.3181     -3160.3181     -3225.2705     -3225.2705      251.37274      251.37274      44278.748      44278.748      230.98869      230.98869    
     40000  -3155.2258     -3155.2258     -3222.1847     -3222.1847      259.13775      259.13775      44509.119      44509.119     -171.978       -171.978      
Loop time of 192.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.448 ns/day, 53.537 hours/ns, 5.189 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.71     | 191.71     | 191.71     |   0.0 | 99.47
Neigh   | 0.45678    | 0.45678    | 0.45678    |   0.0 |  0.24
Comm    | 0.097481   | 0.097481   | 0.097481   |   0.0 |  0.05
Output  | 0.00020657 | 0.00020657 | 0.00020657 |   0.0 |  0.00
Modify  | 0.41108    | 0.41108    | 0.41108    |   0.0 |  0.21
Other   |            | 0.05912    |            |       |  0.03

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0