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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -3210.6958     -3210.6958     -3296.7787     -3296.7787      333.15         333.15         44065.941      44065.941      2086.5727      2086.5727    
      1000  -3110.0219     -3110.0219     -3198.0303     -3198.0303      340.60176      340.60176      45378.013      45378.013     -775.16093     -775.16093    
Loop time of 175.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.732 hours/ns, 5.700 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.52     | 174.52     | 174.52     |   0.0 | 99.48
Neigh   | 0.43107    | 0.43107    | 0.43107    |   0.0 |  0.25
Comm    | 0.087854   | 0.087854   | 0.087854   |   0.0 |  0.05
Output  | 0.00020778 | 0.00020778 | 0.00020778 |   0.0 |  0.00
Modify  | 0.34059    | 0.34059    | 0.34059    |   0.0 |  0.19
Other   |            | 0.05565    |            |       |  0.03

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

Total # of neighbors = 120602
Ave neighs/atom = 60.301
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   
      1000  -3110.0219     -3110.0219     -3198.0303     -3198.0303      340.60176      340.60176      45378.013      45378.013     -775.16093     -775.16093    
      2000  -3119.8551     -3119.8551     -3202.5303     -3202.5303      319.96166      319.96166      45003.616      45003.616     -150.64516     -150.64516    
Loop time of 172.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.004 hours/ns, 5.787 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    | 171.82     | 171.82     | 171.82     |   0.0 | 99.42
Neigh   | 0.51861    | 0.51861    | 0.51861    |   0.0 |  0.30
Comm    | 0.0888     | 0.0888     | 0.0888     |   0.0 |  0.05
Output  | 0.00021042 | 0.00021042 | 0.00021042 |   0.0 |  0.00
Modify  | 0.33258    | 0.33258    | 0.33258    |   0.0 |  0.19
Other   |            | 0.0551     |            |       |  0.03

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

Total # of neighbors = 121134
Ave neighs/atom = 60.567
Neighbor list builds = 24
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  -3119.8551     -3119.8551     -3202.5303     -3202.5303      319.96166      319.96166      45003.616      45003.616     -150.64516     -150.64516    
      3000  -3111.3079     -3111.3079     -3199.0511     -3199.0511      339.57543      339.57543      45065.993      45065.993     -33.741206     -33.741206    
Loop time of 193.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.742 hours/ns, 5.169 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    | 192.37     | 192.37     | 192.37     |   0.0 | 99.43
Neigh   | 0.55203    | 0.55203    | 0.55203    |   0.0 |  0.29
Comm    | 0.098813   | 0.098813   | 0.098813   |   0.0 |  0.05
Output  | 0.00027146 | 0.00027146 | 0.00027146 |   0.0 |  0.00
Modify  | 0.39123    | 0.39123    | 0.39123    |   0.0 |  0.20
Other   |            | 0.0591     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3317 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 24
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   
      3000  -3111.3079     -3111.3079     -3199.0511     -3199.0511      339.57543      339.57543      45065.993      45065.993     -33.741206     -33.741206    
      4000  -3115.8714     -3115.8714     -3203.0022     -3203.0022      337.20498      337.20498      44801.471      44801.471      455.27935      455.27935    
Loop time of 195.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.436 hours/ns, 5.103 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    | 194.84     | 194.84     | 194.84     |   0.0 | 99.43
Neigh   | 0.56203    | 0.56203    | 0.56203    |   0.0 |  0.29
Comm    | 0.10029    | 0.10029    | 0.10029    |   0.0 |  0.05
Output  | 0.00023448 | 0.00023448 | 0.00023448 |   0.0 |  0.00
Modify  | 0.40434    | 0.40434    | 0.40434    |   0.0 |  0.21
Other   |            | 0.0597     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3297 ave        3297 max        3297 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121222 ave      121222 max      121222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121222
Ave neighs/atom = 60.611
Neighbor list builds = 24
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   
      4000  -3115.8714     -3115.8714     -3203.0022     -3203.0022      337.20498      337.20498      44801.471      44801.471      455.27935      455.27935    
      5000  -3112.3727     -3112.3727     -3200.2851     -3200.2851      340.23008      340.23008      44834.776      44834.776      556.25681      556.25681    
Loop time of 172.645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 47.957 hours/ns, 5.792 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    | 171.64     | 171.64     | 171.64     |   0.0 | 99.42
Neigh   | 0.51912    | 0.51912    | 0.51912    |   0.0 |  0.30
Comm    | 0.089076   | 0.089076   | 0.089076   |   0.0 |  0.05
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.33642    | 0.33642    | 0.33642    |   0.0 |  0.19
Other   |            | 0.05548    |            |       |  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:       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 = 24
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 = 333.596461890645, Press = 408.790256962479
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  -3112.3727     -3112.3727     -3200.2851     -3200.2851      340.23008      340.23008      44834.776      44834.776      556.25681      556.25681    
      6000  -3115.7552     -3115.7552     -3202.0362     -3202.0362      333.9165       333.9165       44890.502      44890.502      354.95621      354.95621    
Loop time of 172.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.934 hours/ns, 5.795 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    | 171.55     | 171.55     | 171.55     |   0.0 | 99.41
Neigh   | 0.51925    | 0.51925    | 0.51925    |   0.0 |  0.30
Comm    | 0.08943    | 0.08943    | 0.08943    |   0.0 |  0.05
Output  | 0.00016665 | 0.00016665 | 0.00016665 |   0.0 |  0.00
Modify  | 0.35178    | 0.35178    | 0.35178    |   0.0 |  0.20
Other   |            | 0.05458    |            |       |  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:       121244 ave      121244 max      121244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121244
Ave neighs/atom = 60.622
Neighbor list builds = 24
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 = 334.68190506362, Press = 39.2948942615981
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   
      6000  -3115.7552     -3115.7552     -3202.0362     -3202.0362      333.9165       333.9165       44890.502      44890.502      354.95621      354.95621    
      7000  -3111.5715     -3111.5715     -3197.6677     -3197.6677      333.20105      333.20105      45103.173      45103.173     -76.691189     -76.691189    
Loop time of 172.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.951 hours/ns, 5.793 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    | 171.59     | 171.59     | 171.59     |   0.0 | 99.40
Neigh   | 0.54018    | 0.54018    | 0.54018    |   0.0 |  0.31
Comm    | 0.089647   | 0.089647   | 0.089647   |   0.0 |  0.05
Output  | 0.00016568 | 0.00016568 | 0.00016568 |   0.0 |  0.00
Modify  | 0.35299    | 0.35299    | 0.35299    |   0.0 |  0.20
Other   |            | 0.05418    |            |       |  0.03

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

Total # of neighbors = 120978
Ave neighs/atom = 60.489
Neighbor list builds = 25
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 = 333.95265460515, Press = 22.2614307709515
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   
      7000  -3111.5715     -3111.5715     -3197.6677     -3197.6677      333.20105      333.20105      45103.173      45103.173     -76.691189     -76.691189    
      8000  -3115.6003     -3115.6003     -3201.1716     -3201.1716      331.17006      331.17006      45053.823      45053.823     -151.86455     -151.86455    
Loop time of 172.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 47.954 hours/ns, 5.793 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    | 171.62     | 171.62     | 171.62     |   0.0 | 99.41
Neigh   | 0.51941    | 0.51941    | 0.51941    |   0.0 |  0.30
Comm    | 0.089302   | 0.089302   | 0.089302   |   0.0 |  0.05
Output  | 0.00016855 | 0.00016855 | 0.00016855 |   0.0 |  0.00
Modify  | 0.35231    | 0.35231    | 0.35231    |   0.0 |  0.20
Other   |            | 0.05494    |            |       |  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:       121176 ave      121176 max      121176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121176
Ave neighs/atom = 60.588
Neighbor list builds = 24
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 = 334.653362653429, Press = 13.4087020516432
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  -3115.6003     -3115.6003     -3201.1716     -3201.1716      331.17006      331.17006      45053.823      45053.823     -151.86455     -151.86455    
      9000  -3111.0183     -3111.0183     -3198.4861     -3198.4861      338.50943      338.50943      45138.052      45138.052     -188.83198     -188.83198    
Loop time of 186.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.464 ns/day, 51.717 hours/ns, 5.371 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.07     | 185.07     | 185.07     |   0.0 | 99.40
Neigh   | 0.56504    | 0.56504    | 0.56504    |   0.0 |  0.30
Comm    | 0.095241   | 0.095241   | 0.095241   |   0.0 |  0.05
Output  | 0.0001984  | 0.0001984  | 0.0001984  |   0.0 |  0.00
Modify  | 0.39355    | 0.39355    | 0.39355    |   0.0 |  0.21
Other   |            | 0.05753    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3320 ave        3320 max        3320 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 = 25
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 = 334.280369016315, Press = 13.3981686871077
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  -3111.0183     -3111.0183     -3198.4861     -3198.4861      338.50943      338.50943      45138.052      45138.052     -188.83198     -188.83198    
     10000  -3115.5295     -3115.5295     -3201.077      -3201.077       331.07773      331.07773      45020.561      45020.561     -59.775775     -59.775775    
Loop time of 202.94 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.372 hours/ns, 4.928 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    | 201.74     | 201.74     | 201.74     |   0.0 | 99.41
Neigh   | 0.5915     | 0.5915     | 0.5915     |   0.0 |  0.29
Comm    | 0.10296    | 0.10296    | 0.10296    |   0.0 |  0.05
Output  | 0.00022983 | 0.00022983 | 0.00022983 |   0.0 |  0.00
Modify  | 0.44065    | 0.44065    | 0.44065    |   0.0 |  0.22
Other   |            | 0.06022    |            |       |  0.03

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

Total # of neighbors = 121076
Ave neighs/atom = 60.538
Neighbor list builds = 25
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 = 334.515129958601, Press = 4.25135472456344
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  -3115.5295     -3115.5295     -3201.077      -3201.077       331.07773      331.07773      45020.561      45020.561     -59.775775     -59.775775    
     11000  -3116.9558     -3116.9558     -3203.0041     -3203.0041      333.01561      333.01561      44820.941      44820.941      375.17066      375.17066    
Loop time of 201.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.429 ns/day, 56.006 hours/ns, 4.960 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.46     | 200.46     | 200.46     |   0.0 | 99.42
Neigh   | 0.56582    | 0.56582    | 0.56582    |   0.0 |  0.28
Comm    | 0.10169    | 0.10169    | 0.10169    |   0.0 |  0.05
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.43839    | 0.43839    | 0.43839    |   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:           3338 ave        3338 max        3338 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 = 24
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 = 334.254825419913, Press = 4.33738649041948
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  -3116.9558     -3116.9558     -3203.0041     -3203.0041      333.01561      333.01561      44820.941      44820.941      375.17066      375.17066    
     12000  -3110.9912     -3110.9912     -3199.4431     -3199.4431      342.31791      342.31791      44996.538      44996.538      159.37138      159.37138    
Loop time of 196.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.600 hours/ns, 5.087 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    | 195.42     | 195.42     | 195.42     |   0.0 | 99.42
Neigh   | 0.55936    | 0.55936    | 0.55936    |   0.0 |  0.28
Comm    | 0.10046    | 0.10046    | 0.10046    |   0.0 |  0.05
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.42274    | 0.42274    | 0.42274    |   0.0 |  0.22
Other   |            | 0.05944    |            |       |  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:       121186 ave      121186 max      121186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121186
Ave neighs/atom = 60.593
Neighbor list builds = 24
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 = 334.316933133164, Press = 1.44540732550168
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   
     12000  -3110.9912     -3110.9912     -3199.4431     -3199.4431      342.31791      342.31791      44996.538      44996.538      159.37138      159.37138    
     13000  -3113.4635     -3113.4635     -3200.9828     -3200.9828      338.70885      338.70885      44900.641      44900.641      323.12027      323.12027    
Loop time of 202.63 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.286 hours/ns, 4.935 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    | 201.43     | 201.43     | 201.43     |   0.0 | 99.41
Neigh   | 0.59425    | 0.59425    | 0.59425    |   0.0 |  0.29
Comm    | 0.10387    | 0.10387    | 0.10387    |   0.0 |  0.05
Output  | 0.0001683  | 0.0001683  | 0.0001683  |   0.0 |  0.00
Modify  | 0.4388     | 0.4388     | 0.4388     |   0.0 |  0.22
Other   |            | 0.06083    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3279 ave        3279 max        3279 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121140 ave      121140 max      121140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121140
Ave neighs/atom = 60.57
Neighbor list builds = 25
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 = 334.144132247636, Press = 9.55765578535022
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  -3113.4635     -3113.4635     -3200.9828     -3200.9828      338.70885      338.70885      44900.641      44900.641      323.12027      323.12027    
     14000  -3116.5911     -3116.5911     -3202.7498     -3202.7498      333.44309      333.44309      44987.418      44987.418     -10.009886     -10.009886    
Loop time of 190.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.454 ns/day, 52.842 hours/ns, 5.257 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    | 189.13     | 189.13     | 189.13     |   0.0 | 99.42
Neigh   | 0.5474     | 0.5474     | 0.5474     |   0.0 |  0.29
Comm    | 0.09807    | 0.09807    | 0.09807    |   0.0 |  0.05
Output  | 0.0005709  | 0.0005709  | 0.0005709  |   0.0 |  0.00
Modify  | 0.40041    | 0.40041    | 0.40041    |   0.0 |  0.21
Other   |            | 0.05817    |            |       |  0.03

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

Total # of neighbors = 121270
Ave neighs/atom = 60.635
Neighbor list builds = 24
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 = 334.005380523145, Press = 11.9931606524819
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   
     14000  -3116.5911     -3116.5911     -3202.7498     -3202.7498      333.44309      333.44309      44987.418      44987.418     -10.009886     -10.009886    
     15000  -3116.8489     -3116.8489     -3201.0427     -3201.0427      325.8387       325.8387       45023.255      45023.255     -77.209221     -77.209221    
Loop time of 202.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.362 hours/ns, 4.928 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    | 201.7      | 201.7      | 201.7      |   0.0 | 99.41
Neigh   | 0.59697    | 0.59697    | 0.59697    |   0.0 |  0.29
Comm    | 0.10291    | 0.10291    | 0.10291    |   0.0 |  0.05
Output  | 0.00026547 | 0.00026547 | 0.00026547 |   0.0 |  0.00
Modify  | 0.4368     | 0.4368     | 0.4368     |   0.0 |  0.22
Other   |            | 0.06038    |            |       |  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:       120916 ave      120916 max      120916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120916
Ave neighs/atom = 60.458
Neighbor list builds = 25
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 = 333.850077836578, Press = 4.71332337190221
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  -3116.8489     -3116.8489     -3201.0427     -3201.0427      325.8387       325.8387       45023.255      45023.255     -77.209221     -77.209221    
     16000  -3113.2599     -3113.2599     -3197.215      -3197.215       324.91506      324.91506      45252.161      45252.161     -453.15611     -453.15611    
Loop time of 202.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.170 hours/ns, 4.945 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    | 201.05     | 201.05     | 201.05     |   0.0 | 99.42
Neigh   | 0.56538    | 0.56538    | 0.56538    |   0.0 |  0.28
Comm    | 0.10231    | 0.10231    | 0.10231    |   0.0 |  0.05
Output  | 0.00024785 | 0.00024785 | 0.00024785 |   0.0 |  0.00
Modify  | 0.43449    | 0.43449    | 0.43449    |   0.0 |  0.21
Other   |            | 0.06029    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3244 ave        3244 max        3244 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120732 ave      120732 max      120732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120732
Ave neighs/atom = 60.366
Neighbor list builds = 24
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 = 333.603803246115, Press = 2.93673574073347
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   
     16000  -3113.2599     -3113.2599     -3197.215      -3197.215       324.91506      324.91506      45252.161      45252.161     -453.15611     -453.15611    
     17000  -3119.3645     -3119.3645     -3201.466      -3201.466       317.7411       317.7411       45009.827      45009.827     -119.70801     -119.70801    
Loop time of 202.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.267 hours/ns, 4.937 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    | 201.37     | 201.37     | 201.37     |   0.0 | 99.41
Neigh   | 0.59254    | 0.59254    | 0.59254    |   0.0 |  0.29
Comm    | 0.10235    | 0.10235    | 0.10235    |   0.0 |  0.05
Output  | 0.00023386 | 0.00023386 | 0.00023386 |   0.0 |  0.00
Modify  | 0.43762    | 0.43762    | 0.43762    |   0.0 |  0.22
Other   |            | 0.0599     |            |       |  0.03

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

Total # of neighbors = 121014
Ave neighs/atom = 60.507
Neighbor list builds = 25
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 = 333.420092426827, Press = 1.44974400707489
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  -3119.3645     -3119.3645     -3201.466      -3201.466       317.7411       317.7411       45009.827      45009.827     -119.70801     -119.70801    
     18000  -3112.2649     -3112.2649     -3199.6342     -3199.6342      338.12836      338.12836      45059.867      45059.867     -73.253958     -73.253958    
Loop time of 202.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.212 hours/ns, 4.942 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    | 201.22     | 201.22     | 201.22     |   0.0 | 99.43
Neigh   | 0.54573    | 0.54573    | 0.54573    |   0.0 |  0.27
Comm    | 0.1026     | 0.1026     | 0.1026     |   0.0 |  0.05
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.43778    | 0.43778    | 0.43778    |   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:           3365 ave        3365 max        3365 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 23
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 = 333.296885353901, Press = 2.86611728881857
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   
     18000  -3112.2649     -3112.2649     -3199.6342     -3199.6342      338.12836      338.12836      45059.867      45059.867     -73.253958     -73.253958    
     19000  -3117.4996     -3117.4996     -3202.3801     -3202.3801      328.49631      328.49631      44864.149      44864.149      308.96009      308.96009    
Loop time of 189.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.455 ns/day, 52.732 hours/ns, 5.268 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    | 188.73     | 188.73     | 188.73     |   0.0 | 99.42
Neigh   | 0.54912    | 0.54912    | 0.54912    |   0.0 |  0.29
Comm    | 0.097449   | 0.097449   | 0.097449   |   0.0 |  0.05
Output  | 0.00016909 | 0.00016909 | 0.00016909 |   0.0 |  0.00
Modify  | 0.40041    | 0.40041    | 0.40041    |   0.0 |  0.21
Other   |            | 0.0581     |            |       |  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:       121184 ave      121184 max      121184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121184
Ave neighs/atom = 60.592
Neighbor list builds = 24
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 = 333.325552751577, Press = 3.08967938211986
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  -3117.4996     -3117.4996     -3202.3801     -3202.3801      328.49631      328.49631      44864.149      44864.149      308.96009      308.96009    
     20000  -3113.5122     -3113.5122     -3201.837      -3201.837       341.82626      341.82626      44862.473      44862.473      419.80002      419.80002    
Loop time of 202.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.238 hours/ns, 4.939 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    | 201.29     | 201.29     | 201.29     |   0.0 | 99.42
Neigh   | 0.569      | 0.569      | 0.569      |   0.0 |  0.28
Comm    | 0.10253    | 0.10253    | 0.10253    |   0.0 |  0.05
Output  | 0.00017025 | 0.00017025 | 0.00017025 |   0.0 |  0.00
Modify  | 0.43699    | 0.43699    | 0.43699    |   0.0 |  0.22
Other   |            | 0.06085    |            |       |  0.03

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

Total # of neighbors = 121360
Ave neighs/atom = 60.68
Neighbor list builds = 24
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 = 333.229717871862, Press = 4.56892335375993
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  -3113.5122     -3113.5122     -3201.837      -3201.837       341.82626      341.82626      44862.473      44862.473      419.80002      419.80002    
     21000  -3114.5702     -3114.5702     -3199.1313     -3199.1313      327.26022      327.26022      44974.402      44974.402      82.350473      82.350473    
Loop time of 202.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.280 hours/ns, 4.936 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    | 201.42     | 201.42     | 201.42     |   0.0 | 99.41
Neigh   | 0.5869     | 0.5869     | 0.5869     |   0.0 |  0.29
Comm    | 0.10333    | 0.10333    | 0.10333    |   0.0 |  0.05
Output  | 0.0002038  | 0.0002038  | 0.0002038  |   0.0 |  0.00
Modify  | 0.43619    | 0.43619    | 0.43619    |   0.0 |  0.22
Other   |            | 0.06036    |            |       |  0.03

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

Total # of neighbors = 121340
Ave neighs/atom = 60.67
Neighbor list builds = 25
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 = 333.266248935854, Press = 5.44981888657395
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  -3114.5702     -3114.5702     -3199.1313     -3199.1313      327.26022      327.26022      44974.402      44974.402      82.350473      82.350473    
     22000  -3110.3784     -3110.3784     -3196.6946     -3196.6946      334.05267      334.05267      45165.387      45165.387     -185.42884     -185.42884    
Loop time of 203.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.427 hours/ns, 4.923 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    | 201.94     | 201.94     | 201.94     |   0.0 | 99.41
Neigh   | 0.58844    | 0.58844    | 0.58844    |   0.0 |  0.29
Comm    | 0.10137    | 0.10137    | 0.10137    |   0.0 |  0.05
Output  | 0.00020952 | 0.00020952 | 0.00020952 |   0.0 |  0.00
Modify  | 0.44245    | 0.44245    | 0.44245    |   0.0 |  0.22
Other   |            | 0.06086    |            |       |  0.03

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

Total # of neighbors = 121014
Ave neighs/atom = 60.507
Neighbor list builds = 25
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 = 333.359167524099, Press = 5.05785093173502
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  -3110.3784     -3110.3784     -3196.6946     -3196.6946      334.05267      334.05267      45165.387      45165.387     -185.42884     -185.42884    
     23000  -3115.6455     -3115.6455     -3202.2648     -3202.2648      335.22574      335.22574      44972.028      44972.028     -3.2506388     -3.2506388    
Loop time of 203.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.434 hours/ns, 4.922 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    | 201.96     | 201.96     | 201.96     |   0.0 | 99.41
Neigh   | 0.59346    | 0.59346    | 0.59346    |   0.0 |  0.29
Comm    | 0.10361    | 0.10361    | 0.10361    |   0.0 |  0.05
Output  | 0.00016542 | 0.00016542 | 0.00016542 |   0.0 |  0.00
Modify  | 0.44191    | 0.44191    | 0.44191    |   0.0 |  0.22
Other   |            | 0.06127    |            |       |  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:       121242 ave      121242 max      121242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121242
Ave neighs/atom = 60.621
Neighbor list builds = 25
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 = 333.487497056876, Press = 2.14034907972875
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  -3115.6455     -3115.6455     -3202.2648     -3202.2648      335.22574      335.22574      44972.028      44972.028     -3.2506388     -3.2506388    
     24000  -3110.8478     -3110.8478     -3196.9201     -3196.9201      333.10851      333.10851      45197.67       45197.67      -247.16875     -247.16875    
Loop time of 201.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.429 ns/day, 55.931 hours/ns, 4.966 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.18     | 200.18     | 200.18     |   0.0 | 99.42
Neigh   | 0.56814    | 0.56814    | 0.56814    |   0.0 |  0.28
Comm    | 0.10243    | 0.10243    | 0.10243    |   0.0 |  0.05
Output  | 0.0001672  | 0.0001672  | 0.0001672  |   0.0 |  0.00
Modify  | 0.43961    | 0.43961    | 0.43961    |   0.0 |  0.22
Other   |            | 0.0607     |            |       |  0.03

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

Total # of neighbors = 121220
Ave neighs/atom = 60.61
Neighbor list builds = 24
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 = 333.523604243588, Press = 2.42495704871383
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   
     24000  -3110.8478     -3110.8478     -3196.9201     -3196.9201      333.10851      333.10851      45197.67       45197.67      -247.16875     -247.16875    
     25000  -3116.3608     -3116.3608     -3200.8127     -3200.8127      326.83728      326.83728      45087.732      45087.732     -254.84364     -254.84364    
Loop time of 201.915 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.088 hours/ns, 4.953 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.75     | 200.75     | 200.75     |   0.0 | 99.42
Neigh   | 0.56583    | 0.56583    | 0.56583    |   0.0 |  0.28
Comm    | 0.10222    | 0.10222    | 0.10222    |   0.0 |  0.05
Output  | 0.00016925 | 0.00016925 | 0.00016925 |   0.0 |  0.00
Modify  | 0.43641    | 0.43641    | 0.43641    |   0.0 |  0.22
Other   |            | 0.0607     |            |       |  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:       121202 ave      121202 max      121202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121202
Ave neighs/atom = 60.601
Neighbor list builds = 24
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 = 333.575691144527, Press = 1.11858821731744
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  -3116.3608     -3116.3608     -3200.8127     -3200.8127      326.83728      326.83728      45087.732      45087.732     -254.84364     -254.84364    
     26000  -3114.6164     -3114.6164     -3201.3069     -3201.3069      335.50133      335.50133      45062.797      45062.797     -98.234897     -98.234897    
Loop time of 202.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.302 hours/ns, 4.934 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.51     | 201.51     | 201.51     |   0.0 | 99.42
Neigh   | 0.56272    | 0.56272    | 0.56272    |   0.0 |  0.28
Comm    | 0.10369    | 0.10369    | 0.10369    |   0.0 |  0.05
Output  | 0.00018715 | 0.00018715 | 0.00018715 |   0.0 |  0.00
Modify  | 0.44697    | 0.44697    | 0.44697    |   0.0 |  0.22
Other   |            | 0.06087    |            |       |  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:       120868 ave      120868 max      120868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120868
Ave neighs/atom = 60.434
Neighbor list builds = 24
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 = 333.579243859149, Press = -1.6202407839472
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   
     26000  -3114.6164     -3114.6164     -3201.3069     -3201.3069      335.50133      335.50133      45062.797      45062.797     -98.234897     -98.234897    
     27000  -3114.3707     -3114.3707     -3202.2037     -3202.2037      339.92269      339.92269      44815.272      44815.272      488.1083       488.1083     
Loop time of 199.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.433 ns/day, 55.438 hours/ns, 5.011 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    | 198.4      | 198.4      | 198.4      |   0.0 | 99.41
Neigh   | 0.5839     | 0.5839     | 0.5839     |   0.0 |  0.29
Comm    | 0.10278    | 0.10278    | 0.10278    |   0.0 |  0.05
Output  | 0.00016792 | 0.00016792 | 0.00016792 |   0.0 |  0.00
Modify  | 0.42944    | 0.42944    | 0.42944    |   0.0 |  0.22
Other   |            | 0.05997    |            |       |  0.03

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

Total # of neighbors = 121310
Ave neighs/atom = 60.655
Neighbor list builds = 25
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 = 333.504055823126, Press = -0.12957173953135
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  -3114.3707     -3114.3707     -3202.2037     -3202.2037      339.92269      339.92269      44815.272      44815.272      488.1083       488.1083     
     28000  -3118.8006     -3118.8006     -3202.2544     -3202.2544      322.97482      322.97482      44856.749      44856.749      269.92079      269.92079    
Loop time of 192.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.449 ns/day, 53.491 hours/ns, 5.193 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    | 191.45     | 191.45     | 191.45     |   0.0 | 99.42
Neigh   | 0.55128    | 0.55128    | 0.55128    |   0.0 |  0.29
Comm    | 0.098442   | 0.098442   | 0.098442   |   0.0 |  0.05
Output  | 0.00017067 | 0.00017067 | 0.00017067 |   0.0 |  0.00
Modify  | 0.40971    | 0.40971    | 0.40971    |   0.0 |  0.21
Other   |            | 0.05905    |            |       |  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:       121174 ave      121174 max      121174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121174
Ave neighs/atom = 60.587
Neighbor list builds = 24
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 = 333.578084192484, Press = 1.26957072308655
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   
     28000  -3118.8006     -3118.8006     -3202.2544     -3202.2544      322.97482      322.97482      44856.749      44856.749      269.92079      269.92079    
     29000  -3112.8798     -3112.8798     -3198.5709     -3198.5709      331.63364      331.63364      45039.842      45039.842      8.4376468      8.4376468    
Loop time of 203.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.391 hours/ns, 4.926 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    | 201.84     | 201.84     | 201.84     |   0.0 | 99.42
Neigh   | 0.56633    | 0.56633    | 0.56633    |   0.0 |  0.28
Comm    | 0.10173    | 0.10173    | 0.10173    |   0.0 |  0.05
Output  | 0.00016615 | 0.00016615 | 0.00016615 |   0.0 |  0.00
Modify  | 0.43965    | 0.43965    | 0.43965    |   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:           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:       121126 ave      121126 max      121126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121126
Ave neighs/atom = 60.563
Neighbor list builds = 24
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 = 333.494720766166, Press = 2.04448975109198
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   
     29000  -3112.8798     -3112.8798     -3198.5709     -3198.5709      331.63364      331.63364      45039.842      45039.842      8.4376468      8.4376468    
     30000  -3118.6809     -3118.6809     -3205.386      -3205.386       335.55786      335.55786      44857.277      44857.277      164.27229      164.27229    
Loop time of 203.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.447 hours/ns, 4.921 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    | 202.04     | 202.04     | 202.04     |   0.0 | 99.42
Neigh   | 0.56741    | 0.56741    | 0.56741    |   0.0 |  0.28
Comm    | 0.10184    | 0.10184    | 0.10184    |   0.0 |  0.05
Output  | 0.00021266 | 0.00021266 | 0.00021266 |   0.0 |  0.00
Modify  | 0.43881    | 0.43881    | 0.43881    |   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:           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:       120978 ave      120978 max      120978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120978
Ave neighs/atom = 60.489
Neighbor list builds = 24
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 = 333.450093817416, Press = 1.85884315981009
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  -3118.6809     -3118.6809     -3205.386      -3205.386       335.55786      335.55786      44857.277      44857.277      164.27229      164.27229    
     31000  -3113.4761     -3113.4761     -3200.6113     -3200.6113      337.22221      337.22221      44944.568      44944.568      243.22731      243.22731    
Loop time of 203.284 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.468 hours/ns, 4.919 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    | 202.11     | 202.11     | 202.11     |   0.0 | 99.42
Neigh   | 0.56887    | 0.56887    | 0.56887    |   0.0 |  0.28
Comm    | 0.10323    | 0.10323    | 0.10323    |   0.0 |  0.05
Output  | 0.00021328 | 0.00021328 | 0.00021328 |   0.0 |  0.00
Modify  | 0.44013    | 0.44013    | 0.44013    |   0.0 |  0.22
Other   |            | 0.06084    |            |       |  0.03

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

Total # of neighbors = 120886
Ave neighs/atom = 60.443
Neighbor list builds = 24
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 = 333.3676769322, Press = 2.0947877737671
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   
     31000  -3113.4761     -3113.4761     -3200.6113     -3200.6113      337.22221      337.22221      44944.568      44944.568      243.22731      243.22731    
     32000  -3113.4418     -3113.4418     -3200.5685     -3200.5685      337.18947      337.18947      45147.357      45147.357     -278.48539     -278.48539    
Loop time of 203.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.490 hours/ns, 4.917 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    | 202.18     | 202.18     | 202.18     |   0.0 | 99.42
Neigh   | 0.58739    | 0.58739    | 0.58739    |   0.0 |  0.29
Comm    | 0.10364    | 0.10364    | 0.10364    |   0.0 |  0.05
Output  | 0.00022975 | 0.00022975 | 0.00022975 |   0.0 |  0.00
Modify  | 0.43732    | 0.43732    | 0.43732    |   0.0 |  0.22
Other   |            | 0.06042    |            |       |  0.03

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

Total # of neighbors = 121204
Ave neighs/atom = 60.602
Neighbor list builds = 25
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 = 333.40712307237, Press = 4.34993790819959
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  -3113.4418     -3113.4418     -3200.5685     -3200.5685      337.18947      337.18947      45147.357      45147.357     -278.48539     -278.48539    
     33000  -3116.3052     -3116.3052     -3200.8789     -3200.8789      327.30877      327.30877      45174.401      45174.401     -427.42411     -427.42411    
Loop time of 203.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.404 hours/ns, 4.925 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.87     | 201.87     | 201.87     |   0.0 | 99.41
Neigh   | 0.58718    | 0.58718    | 0.58718    |   0.0 |  0.29
Comm    | 0.10326    | 0.10326    | 0.10326    |   0.0 |  0.05
Output  | 0.00017155 | 0.00017155 | 0.00017155 |   0.0 |  0.00
Modify  | 0.43736    | 0.43736    | 0.43736    |   0.0 |  0.22
Other   |            | 0.06062    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3307 ave        3307 max        3307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120932 ave      120932 max      120932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120932
Ave neighs/atom = 60.466
Neighbor list builds = 25
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 = 333.367843240333, Press = 1.67432445832579
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  -3116.3052     -3116.3052     -3200.8789     -3200.8789      327.30877      327.30877      45174.401      45174.401     -427.42411     -427.42411    
     34000  -3113.2315     -3113.2315     -3199.5127     -3199.5127      333.91705      333.91705      45174.777      45174.777     -407.60262     -407.60262    
Loop time of 182.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.474 ns/day, 50.663 hours/ns, 5.483 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    | 181.35     | 181.35     | 181.35     |   0.0 | 99.43
Neigh   | 0.51157    | 0.51157    | 0.51157    |   0.0 |  0.28
Comm    | 0.093651   | 0.093651   | 0.093651   |   0.0 |  0.05
Output  | 0.00016897 | 0.00016897 | 0.00016897 |   0.0 |  0.00
Modify  | 0.37939    | 0.37939    | 0.37939    |   0.0 |  0.21
Other   |            | 0.05685    |            |       |  0.03

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

Total # of neighbors = 121132
Ave neighs/atom = 60.566
Neighbor list builds = 23
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 = 333.268540147692, Press = 2.14848919481598
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   
     34000  -3113.2315     -3113.2315     -3199.5127     -3199.5127      333.91705      333.91705      45174.777      45174.777     -407.60262     -407.60262    
     35000  -3117.7824     -3117.7824     -3200.882      -3200.882       321.60384      321.60384      45043.867      45043.867     -130.3461      -130.3461     
Loop time of 173.141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.095 hours/ns, 5.776 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    | 172.12     | 172.12     | 172.12     |   0.0 | 99.41
Neigh   | 0.51972    | 0.51972    | 0.51972    |   0.0 |  0.30
Comm    | 0.089349   | 0.089349   | 0.089349   |   0.0 |  0.05
Output  | 0.00016992 | 0.00016992 | 0.00016992 |   0.0 |  0.00
Modify  | 0.35604    | 0.35604    | 0.35604    |   0.0 |  0.21
Other   |            | 0.0554     |            |       |  0.03

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

Total # of neighbors = 121090
Ave neighs/atom = 60.545
Neighbor list builds = 24
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 = 333.264616368161, Press = 0.952012585762205
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   
     35000  -3117.7824     -3117.7824     -3200.882      -3200.882       321.60384      321.60384      45043.867      45043.867     -130.3461      -130.3461     
     36000  -3115.0303     -3115.0303     -3199.5414     -3199.5414      327.06684      327.06684      45132.884      45132.884     -302.44862     -302.44862    
Loop time of 174.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.472 hours/ns, 5.731 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.47     | 173.47     | 173.47     |   0.0 | 99.41
Neigh   | 0.52206    | 0.52206    | 0.52206    |   0.0 |  0.30
Comm    | 0.09099    | 0.09099    | 0.09099    |   0.0 |  0.05
Output  | 0.0002149  | 0.0002149  | 0.0002149  |   0.0 |  0.00
Modify  | 0.35862    | 0.35862    | 0.35862    |   0.0 |  0.21
Other   |            | 0.05552    |            |       |  0.03

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

Total # of neighbors = 121002
Ave neighs/atom = 60.501
Neighbor list builds = 24
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 = 333.164288083539, Press = 1.15929076096674
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   
     36000  -3115.0303     -3115.0303     -3199.5414     -3199.5414      327.06684      327.06684      45132.884      45132.884     -302.44862     -302.44862    
     37000  -3112.9158     -3112.9158     -3200.044      -3200.044       337.19524      337.19524      45047.024      45047.024     -163.51669     -163.51669    
Loop time of 202.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.248 hours/ns, 4.938 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    | 201.34     | 201.34     | 201.34     |   0.0 | 99.43
Neigh   | 0.54613    | 0.54613    | 0.54613    |   0.0 |  0.27
Comm    | 0.10279    | 0.10279    | 0.10279    |   0.0 |  0.05
Output  | 0.00016961 | 0.00016961 | 0.00016961 |   0.0 |  0.00
Modify  | 0.43809    | 0.43809    | 0.43809    |   0.0 |  0.22
Other   |            | 0.06091    |            |       |  0.03

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

Total # of neighbors = 121062
Ave neighs/atom = 60.531
Neighbor list builds = 23
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 = 333.185350417094, Press = 0.397136364033621
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  -3112.9158     -3112.9158     -3200.044      -3200.044       337.19524      337.19524      45047.024      45047.024     -163.51669     -163.51669    
     38000  -3115.713      -3115.713      -3200.3032     -3200.3032      327.37264      327.37264      45000.243      45000.243      33.297594      33.297594    
Loop time of 203.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.410 hours/ns, 4.924 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    | 201.9      | 201.9      | 201.9      |   0.0 | 99.42
Neigh   | 0.56474    | 0.56474    | 0.56474    |   0.0 |  0.28
Comm    | 0.10364    | 0.10364    | 0.10364    |   0.0 |  0.05
Output  | 0.00016964 | 0.00016964 | 0.00016964 |   0.0 |  0.00
Modify  | 0.44421    | 0.44421    | 0.44421    |   0.0 |  0.22
Other   |            | 0.06162    |            |       |  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:       121300 ave      121300 max      121300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121300
Ave neighs/atom = 60.65
Neighbor list builds = 24
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 = 333.14991978585, Press = 1.61424393306155
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  -3115.713      -3115.713      -3200.3032     -3200.3032      327.37264      327.37264      45000.243      45000.243      33.297594      33.297594    
     39000  -3114.2111     -3114.2111     -3199.3568     -3199.3568      329.52284      329.52284      45128.432      45128.432     -227.69403     -227.69403    
Loop time of 202.98 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.383 hours/ns, 4.927 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    | 201.8      | 201.8      | 201.8      |   0.0 | 99.42
Neigh   | 0.56829    | 0.56829    | 0.56829    |   0.0 |  0.28
Comm    | 0.10399    | 0.10399    | 0.10399    |   0.0 |  0.05
Output  | 0.00021601 | 0.00021601 | 0.00021601 |   0.0 |  0.00
Modify  | 0.44295    | 0.44295    | 0.44295    |   0.0 |  0.22
Other   |            | 0.06133    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3348 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 24
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 = 333.118638213374, Press = 1.94101878379004
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  -3114.2111     -3114.2111     -3199.3568     -3199.3568      329.52284      329.52284      45128.432      45128.432     -227.69403     -227.69403    
     40000  -3119.9474     -3119.9474     -3203.0726     -3203.0726      321.70297      321.70297      45240.794      45240.794     -729.92673     -729.92673    
Loop time of 203.141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.428 hours/ns, 4.923 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    | 201.94     | 201.94     | 201.94     |   0.0 | 99.41
Neigh   | 0.58959    | 0.58959    | 0.58959    |   0.0 |  0.29
Comm    | 0.10409    | 0.10409    | 0.10409    |   0.0 |  0.05
Output  | 0.00020765 | 0.00020765 | 0.00020765 |   0.0 |  0.00
Modify  | 0.44308    | 0.44308    | 0.44308    |   0.0 |  0.22
Other   |            | 0.06095    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3277 ave        3277 max        3277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120878 ave      120878 max      120878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120878
Ave neighs/atom = 60.439
Neighbor list builds = 25
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 = 333.140253741324, Press = 1.09517163602047
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   
     40000  -3119.9474     -3119.9474     -3203.0726     -3203.0726      321.70297      321.70297      45240.794      45240.794     -729.92673     -729.92673    
     41000  -3118.3438     -3118.3438     -3201.0121     -3201.0121      319.93483      319.93483      45121.039      45121.039     -353.60438     -353.60438    
Loop time of 203.777 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.6      | 202.6      | 202.6      |   0.0 | 99.42
Neigh   | 0.56859    | 0.56859    | 0.56859    |   0.0 |  0.28
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.05
Output  | 0.00021181 | 0.00021181 | 0.00021181 |   0.0 |  0.00
Modify  | 0.43992    | 0.43992    | 0.43992    |   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:           3314 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120900 ave      120900 max      120900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0