# 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 2.851000025868416*${_u_distance}
variable latticeconst_converted equal 2.851000025868416*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100002586842
Lattice spacing in x,y,z = 2.851 2.851 2.851
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.51 28.51 28.51)
  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 (28.51 28.51 28.51)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_EtesamiAsadi_2018_Fe__MO_549900287421_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.5016817912 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_549900287421_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8504.2526     -8504.2526     -8579.9999     -8579.9999      293.15         293.15         23173.502      23173.502      3491.3663      3491.3663    
      1000  -8423.7822     -8423.7822     -8499.3333     -8499.3333      292.39071      292.39071      23349.336      23349.336      2372.6206      2372.6206    
Loop time of 18.9536 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.558 ns/day, 5.265 hours/ns, 52.760 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 18.872     | 18.872     | 18.872     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015386   | 0.015386   | 0.015386   |   0.0 |  0.08
Output  | 0.00014982 | 0.00014982 | 0.00014982 |   0.0 |  0.00
Modify  | 0.060733   | 0.060733   | 0.060733   |   0.0 |  0.32
Other   |            | 0.005362   |            |       |  0.03

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

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8423.7822     -8423.7822     -8499.3333     -8499.3333      292.39071      292.39071      23349.336      23349.336      2372.6206      2372.6206    
      2000  -8424.9968     -8424.9968     -8501.2521     -8501.2521      295.11605      295.11605      23364.534      23364.534      1315.4631      1315.4631    
Loop time of 21.3265 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.051 ns/day, 5.924 hours/ns, 46.890 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.246     | 21.246     | 21.246     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014999   | 0.014999   | 0.014999   |   0.0 |  0.07
Output  | 5.9271e-05 | 5.9271e-05 | 5.9271e-05 |   0.0 |  0.00
Modify  | 0.059758   | 0.059758   | 0.059758   |   0.0 |  0.28
Other   |            | 0.005256   |            |       |  0.02

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

Total # of neighbors = 128190
Ave neighs/atom = 64.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8424.9968     -8424.9968     -8501.2521     -8501.2521      295.11605      295.11605      23364.534      23364.534      1315.4631      1315.4631    
      3000  -8425.7429     -8425.7429     -8498.8919     -8498.8919      283.09387      283.09387      23386.394      23386.394     -347.65383     -347.65383    
Loop time of 21.4382 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.030 ns/day, 5.955 hours/ns, 46.646 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.358     | 21.358     | 21.358     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.07
Output  | 5.4142e-05 | 5.4142e-05 | 5.4142e-05 |   0.0 |  0.00
Modify  | 0.059645   | 0.059645   | 0.059645   |   0.0 |  0.28
Other   |            | 0.005137   |            |       |  0.02

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

Total # of neighbors = 128252
Ave neighs/atom = 64.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8425.7429     -8425.7429     -8498.8919     -8498.8919      283.09387      283.09387      23386.394      23386.394     -347.65383     -347.65383    
      4000  -8423.636      -8423.636      -8498.9259     -8498.9259      291.37955      291.37955      23414.696      23414.696     -2205.4309     -2205.4309    
Loop time of 21.4547 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.027 ns/day, 5.960 hours/ns, 46.610 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    | 21.375     | 21.375     | 21.375     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015055   | 0.015055   | 0.015055   |   0.0 |  0.07
Output  | 5.4122e-05 | 5.4122e-05 | 5.4122e-05 |   0.0 |  0.00
Modify  | 0.059838   | 0.059838   | 0.059838   |   0.0 |  0.28
Other   |            | 0.00512    |            |       |  0.02

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

Total # of neighbors = 128212
Ave neighs/atom = 64.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8423.636      -8423.636      -8498.9259     -8498.9259      291.37955      291.37955      23414.696      23414.696     -2205.4309     -2205.4309    
      5000  -8426.4994     -8426.4994     -8501.7284     -8501.7284      291.14404      291.14404      23414.247      23414.247     -2610.0434     -2610.0434    
Loop time of 21.3961 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.038 ns/day, 5.943 hours/ns, 46.738 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.316     | 21.316     | 21.316     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.07
Output  | 4.3992e-05 | 4.3992e-05 | 4.3992e-05 |   0.0 |  0.00
Modify  | 0.059636   | 0.059636   | 0.059636   |   0.0 |  0.28
Other   |            | 0.005122   |            |       |  0.02

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

Total # of neighbors = 128154
Ave neighs/atom = 64.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.208832674932, Press = 250.683317598192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8426.4994     -8426.4994     -8501.7284     -8501.7284      291.14404      291.14404      23414.247      23414.247     -2610.0434     -2610.0434    
      6000  -8424.5931     -8424.5931     -8501.1552     -8501.1552      296.30323      296.30323      23392.169      23392.169     -804.63176     -804.63176    
Loop time of 21.4467 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.029 ns/day, 5.957 hours/ns, 46.627 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    | 21.365     | 21.365     | 21.365     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.07
Output  | 4.0576e-05 | 4.0576e-05 | 4.0576e-05 |   0.0 |  0.00
Modify  | 0.061829   | 0.061829   | 0.061829   |   0.0 |  0.29
Other   |            | 0.005186   |            |       |  0.02

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

Total # of neighbors = 128140
Ave neighs/atom = 64.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.765869268167, Press = 9.3392603333067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8424.5931     -8424.5931     -8501.1552     -8501.1552      296.30323      296.30323      23392.169      23392.169     -804.63176     -804.63176    
      7000  -8425.1053     -8425.1053     -8500.5873     -8500.5873      292.12287      292.12287      23376.534      23376.534      313.44284      313.44284    
Loop time of 21.4907 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.020 ns/day, 5.970 hours/ns, 46.532 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    | 21.409     | 21.409     | 21.409     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.07
Output  | 4.4163e-05 | 4.4163e-05 | 4.4163e-05 |   0.0 |  0.00
Modify  | 0.06182    | 0.06182    | 0.06182    |   0.0 |  0.29
Other   |            | 0.005181   |            |       |  0.02

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

Total # of neighbors = 128188
Ave neighs/atom = 64.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.710096573795, Press = 11.7655350721921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8425.1053     -8425.1053     -8500.5873     -8500.5873      292.12287      292.12287      23376.534      23376.534      313.44284      313.44284    
      8000  -8424.5352     -8424.5352     -8499.6458     -8499.6458      290.68582      290.68582      23368.608      23368.608      1096.8196      1096.8196    
Loop time of 21.4704 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.024 ns/day, 5.964 hours/ns, 46.576 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    | 21.388     | 21.388     | 21.388     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.07
Output  | 3.5186e-05 | 3.5186e-05 | 3.5186e-05 |   0.0 |  0.00
Modify  | 0.0617     | 0.0617     | 0.0617     |   0.0 |  0.29
Other   |            | 0.005245   |            |       |  0.02

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

Total # of neighbors = 128218
Ave neighs/atom = 64.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.699871490841, Press = 14.9471755644061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8424.5352     -8424.5352     -8499.6458     -8499.6458      290.68582      290.68582      23368.608      23368.608      1096.8196      1096.8196    
      9000  -8423.4984     -8423.4984     -8501.912      -8501.912       303.46872      303.46872      23381.187      23381.187      76.239073      76.239073    
Loop time of 21.4494 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.028 ns/day, 5.958 hours/ns, 46.621 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    | 21.367     | 21.367     | 21.367     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.07
Output  | 4.4784e-05 | 4.4784e-05 | 4.4784e-05 |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.29
Other   |            | 0.005256   |            |       |  0.02

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

Total # of neighbors = 128262
Ave neighs/atom = 64.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.435957727061, Press = 9.61915743749951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8423.4984     -8423.4984     -8501.912      -8501.912       303.46872      303.46872      23381.187      23381.187      76.239073      76.239073    
     10000  -8420.8927     -8420.8927     -8496.3161     -8496.3161      291.89616      291.89616      23391.92       23391.92      -141.51104     -141.51104    
Loop time of 21.5793 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.004 ns/day, 5.994 hours/ns, 46.341 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    | 21.497     | 21.497     | 21.497     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015041   | 0.015041   | 0.015041   |   0.0 |  0.07
Output  | 3.8642e-05 | 3.8642e-05 | 3.8642e-05 |   0.0 |  0.00
Modify  | 0.061671   | 0.061671   | 0.061671   |   0.0 |  0.29
Other   |            | 0.005225   |            |       |  0.02

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

Total # of neighbors = 128164
Ave neighs/atom = 64.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.521298167833, Press = 8.81715475402051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8420.8927     -8420.8927     -8496.3161     -8496.3161      291.89616      291.89616      23391.92       23391.92      -141.51104     -141.51104    
     11000  -8425.0551     -8425.0551     -8501.7877     -8501.7877      296.96323      296.96323      23392.12       23392.12      -862.95386     -862.95386    
Loop time of 21.4326 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.031 ns/day, 5.954 hours/ns, 46.658 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.351     | 21.351     | 21.351     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.07
Output  | 4.846e-05  | 4.846e-05  | 4.846e-05  |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.29
Other   |            | 0.005123   |            |       |  0.02

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

Total # of neighbors = 128240
Ave neighs/atom = 64.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.005350743802, Press = 5.3758621239821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8425.0551     -8425.0551     -8501.7877     -8501.7877      296.96323      296.96323      23392.12       23392.12      -862.95386     -862.95386    
     12000  -8423.7519     -8423.7519     -8498.6213     -8498.6213      289.75225      289.75225      23407.257      23407.257     -1652.249      -1652.249     
Loop time of 21.5026 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.018 ns/day, 5.973 hours/ns, 46.506 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    | 21.421     | 21.421     | 21.421     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.07
Output  | 3.7811e-05 | 3.7811e-05 | 3.7811e-05 |   0.0 |  0.00
Modify  | 0.06156    | 0.06156    | 0.06156    |   0.0 |  0.29
Other   |            | 0.005136   |            |       |  0.02

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.978355284367, Press = 4.90239110868326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8423.7519     -8423.7519     -8498.6213     -8498.6213      289.75225      289.75225      23407.257      23407.257     -1652.249      -1652.249     
     13000  -8425.9918     -8425.9918     -8500.4889     -8500.4889      288.31127      288.31127      23417.415      23417.415     -2691.8419     -2691.8419    
Loop time of 21.4331 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.031 ns/day, 5.954 hours/ns, 46.657 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    | 21.351     | 21.351     | 21.351     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.07
Output  | 3.5767e-05 | 3.5767e-05 | 3.5767e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.29
Other   |            | 0.005097   |            |       |  0.02

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

Total # of neighbors = 128188
Ave neighs/atom = 64.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.909650333267, Press = 2.04600814373691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8425.9918     -8425.9918     -8500.4889     -8500.4889      288.31127      288.31127      23417.415      23417.415     -2691.8419     -2691.8419    
     14000  -8425.0941     -8425.0941     -8500.3334     -8500.3334      291.18405      291.18405      23409.858      23409.858     -2105.3134     -2105.3134    
Loop time of 21.4482 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.028 ns/day, 5.958 hours/ns, 46.624 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    | 21.366     | 21.366     | 21.366     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014931   | 0.014931   | 0.014931   |   0.0 |  0.07
Output  | 7.7596e-05 | 7.7596e-05 | 7.7596e-05 |   0.0 |  0.00
Modify  | 0.061655   | 0.061655   | 0.061655   |   0.0 |  0.29
Other   |            | 0.00511    |            |       |  0.02

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

Total # of neighbors = 128162
Ave neighs/atom = 64.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.963243420944, Press = -2.28711929005552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8425.0941     -8425.0941     -8500.3334     -8500.3334      291.18405      291.18405      23409.858      23409.858     -2105.3134     -2105.3134    
     15000  -8425.1053     -8425.1053     -8502.0536     -8502.0536      297.79781      297.79781      23390.014      23390.014     -777.69608     -777.69608    
Loop time of 21.5177 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.015 ns/day, 5.977 hours/ns, 46.473 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    | 21.436     | 21.436     | 21.436     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.07
Output  | 3.6148e-05 | 3.6148e-05 | 3.6148e-05 |   0.0 |  0.00
Modify  | 0.061634   | 0.061634   | 0.061634   |   0.0 |  0.29
Other   |            | 0.005138   |            |       |  0.02

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.87799466538, Press = -3.76815394541835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8425.1053     -8425.1053     -8502.0536     -8502.0536      297.79781      297.79781      23390.014      23390.014     -777.69608     -777.69608    
     16000  -8426.3029     -8426.3029     -8502.3676     -8502.3676      294.37815      294.37815      23369.362      23369.362      625.82284      625.82284    
Loop time of 21.4994 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.019 ns/day, 5.972 hours/ns, 46.513 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    | 21.417     | 21.417     | 21.417     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015097   | 0.015097   | 0.015097   |   0.0 |  0.07
Output  | 3.751e-05  | 3.751e-05  | 3.751e-05  |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.29
Other   |            | 0.005166   |            |       |  0.02

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

Total # of neighbors = 128176
Ave neighs/atom = 64.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921321716199, Press = -1.25062198519089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8426.3029     -8426.3029     -8502.3676     -8502.3676      294.37815      294.37815      23369.362      23369.362      625.82284      625.82284    
     17000  -8421.4902     -8421.4902     -8499.1733     -8499.1733      300.64141      300.64141      23369.574      23369.574      1172.8075      1172.8075    
Loop time of 21.4585 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.026 ns/day, 5.961 hours/ns, 46.601 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    | 21.377     | 21.377     | 21.377     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.07
Output  | 4.7218e-05 | 4.7218e-05 | 4.7218e-05 |   0.0 |  0.00
Modify  | 0.061615   | 0.061615   | 0.061615   |   0.0 |  0.29
Other   |            | 0.005131   |            |       |  0.02

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.097527283611, Press = 1.46991994696207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8421.4902     -8421.4902     -8499.1733     -8499.1733      300.64141      300.64141      23369.574      23369.574      1172.8075      1172.8075    
     18000  -8426.9439     -8426.9439     -8501.9528     -8501.9528      290.29251      290.29251      23360.138      23360.138      1227.5412      1227.5412    
Loop time of 21.4372 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.030 ns/day, 5.955 hours/ns, 46.648 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    | 21.355     | 21.355     | 21.355     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014966   | 0.014966   | 0.014966   |   0.0 |  0.07
Output  | 4.2399e-05 | 4.2399e-05 | 4.2399e-05 |   0.0 |  0.00
Modify  | 0.061615   | 0.061615   | 0.061615   |   0.0 |  0.29
Other   |            | 0.00513    |            |       |  0.02

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

Total # of neighbors = 128230
Ave neighs/atom = 64.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.148056670152, Press = 1.93735221444368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8426.9439     -8426.9439     -8501.9528     -8501.9528      290.29251      290.29251      23360.138      23360.138      1227.5412      1227.5412    
     19000  -8425.8811     -8425.8811     -8501.4335     -8501.4335      292.39574      292.39574      23362.663      23362.663      1257.901       1257.901     
Loop time of 21.4154 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.034 ns/day, 5.949 hours/ns, 46.695 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    | 21.334     | 21.334     | 21.334     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.07
Output  | 4.2309e-05 | 4.2309e-05 | 4.2309e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.29
Other   |            | 0.005151   |            |       |  0.02

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

Total # of neighbors = 128184
Ave neighs/atom = 64.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.105868682615, Press = 3.33049450735899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8425.8811     -8425.8811     -8501.4335     -8501.4335      292.39574      292.39574      23362.663      23362.663      1257.901       1257.901     
     20000  -8424.7584     -8424.7584     -8501.0476     -8501.0476      295.24721      295.24721      23358.985      23358.985      1586.5907      1586.5907    
Loop time of 21.4559 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.027 ns/day, 5.960 hours/ns, 46.607 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    | 21.374     | 21.374     | 21.374     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.07
Output  | 3.6769e-05 | 3.6769e-05 | 3.6769e-05 |   0.0 |  0.00
Modify  | 0.061677   | 0.061677   | 0.061677   |   0.0 |  0.29
Other   |            | 0.005129   |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.928667161856, Press = 6.7049098729073
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8424.7584     -8424.7584     -8501.0476     -8501.0476      295.24721      295.24721      23358.985      23358.985      1586.5907      1586.5907    
     21000  -8423.8659     -8423.8659     -8499.3577     -8499.3577      292.16122      292.16122      23368.108      23368.108      1138.6286      1138.6286    
Loop time of 21.5024 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.018 ns/day, 5.973 hours/ns, 46.507 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    | 21.42      | 21.42      | 21.42      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015059   | 0.015059   | 0.015059   |   0.0 |  0.07
Output  | 3.8262e-05 | 3.8262e-05 | 3.8262e-05 |   0.0 |  0.00
Modify  | 0.062037   | 0.062037   | 0.062037   |   0.0 |  0.29
Other   |            | 0.005123   |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847498262714, Press = 8.82265778892423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8423.8659     -8423.8659     -8499.3577     -8499.3577      292.16122      292.16122      23368.108      23368.108      1138.6286      1138.6286    
     22000  -8424.9711     -8424.9711     -8498.97       -8498.97        286.38359      286.38359      23388.663      23388.663     -414.83478     -414.83478    
Loop time of 21.5551 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.008 ns/day, 5.988 hours/ns, 46.393 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    | 21.473     | 21.473     | 21.473     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.07
Output  | 4.8691e-05 | 4.8691e-05 | 4.8691e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.29
Other   |            | 0.005138   |            |       |  0.02

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

Total # of neighbors = 128174
Ave neighs/atom = 64.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776050776888, Press = 6.03194672326925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8424.9711     -8424.9711     -8498.97       -8498.97        286.38359      286.38359      23388.663      23388.663     -414.83478     -414.83478    
     23000  -8426.753      -8426.753      -8502.3453     -8502.3453      292.5499       292.5499       23391.266      23391.266     -1016.1448     -1016.1448    
Loop time of 21.5235 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.014 ns/day, 5.979 hours/ns, 46.461 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    | 21.442     | 21.442     | 21.442     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015052   | 0.015052   | 0.015052   |   0.0 |  0.07
Output  | 3.6198e-05 | 3.6198e-05 | 3.6198e-05 |   0.0 |  0.00
Modify  | 0.0617     | 0.0617     | 0.0617     |   0.0 |  0.29
Other   |            | 0.005121   |            |       |  0.02

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

Total # of neighbors = 128190
Ave neighs/atom = 64.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790794361698, Press = 3.18840718780657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8426.753      -8426.753      -8502.3453     -8502.3453      292.5499       292.5499       23391.266      23391.266     -1016.1448     -1016.1448    
     24000  -8424.7475     -8424.7475     -8500.8121     -8500.8121      294.37787      294.37787      23404.789      23404.789     -1723.4425     -1723.4425    
Loop time of 21.5041 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.018 ns/day, 5.973 hours/ns, 46.503 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    | 21.422     | 21.422     | 21.422     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01496    | 0.01496    | 0.01496    |   0.0 |  0.07
Output  | 3.6879e-05 | 3.6879e-05 | 3.6879e-05 |   0.0 |  0.00
Modify  | 0.061726   | 0.061726   | 0.061726   |   0.0 |  0.29
Other   |            | 0.005128   |            |       |  0.02

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

Total # of neighbors = 128186
Ave neighs/atom = 64.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.666872733741, Press = 1.38975341053705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8424.7475     -8424.7475     -8500.8121     -8500.8121      294.37787      294.37787      23404.789      23404.789     -1723.4425     -1723.4425    
     25000  -8428.7312     -8428.7312     -8503.2476     -8503.2476      288.38619      288.38619      23395.157      23395.157     -1471.9273     -1471.9273    
Loop time of 21.5205 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.015 ns/day, 5.978 hours/ns, 46.467 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    | 21.439     | 21.439     | 21.439     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.07
Output  | 4.766e-05  | 4.766e-05  | 4.766e-05  |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.29
Other   |            | 0.005117   |            |       |  0.02

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

Total # of neighbors = 128202
Ave neighs/atom = 64.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.622285269228, Press = -0.09841232003833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8428.7312     -8428.7312     -8503.2476     -8503.2476      288.38619      288.38619      23395.157      23395.157     -1471.9273     -1471.9273    
     26000  -8423.0075     -8423.0075     -8499.4104     -8499.4104      295.68691      295.68691      23407.72       23407.72      -1646.2755     -1646.2755    
Loop time of 21.6227 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.006 hours/ns, 46.248 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    | 21.541     | 21.541     | 21.541     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.07
Output  | 3.8933e-05 | 3.8933e-05 | 3.8933e-05 |   0.0 |  0.00
Modify  | 0.061738   | 0.061738   | 0.061738   |   0.0 |  0.29
Other   |            | 0.005154   |            |       |  0.02

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

Total # of neighbors = 128166
Ave neighs/atom = 64.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.564994734065, Press = -1.5533692594013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8423.0075     -8423.0075     -8499.4104     -8499.4104      295.68691      295.68691      23407.72       23407.72      -1646.2755     -1646.2755    
     27000  -8426.0223     -8426.0223     -8501.1813     -8501.1813      290.87285      290.87285      23377.29       23377.29       252.20187      252.20187    
Loop time of 21.4845 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.021 ns/day, 5.968 hours/ns, 46.545 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    | 21.403     | 21.403     | 21.403     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015007   | 0.015007   | 0.015007   |   0.0 |  0.07
Output  | 3.773e-05  | 3.773e-05  | 3.773e-05  |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.29
Other   |            | 0.005124   |            |       |  0.02

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.607697317712, Press = -1.85363984091173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8426.0223     -8426.0223     -8501.1813     -8501.1813      290.87285      290.87285      23377.29       23377.29       252.20187      252.20187    
     28000  -8423.5441     -8423.5441     -8499.6189     -8499.6189      294.41739      294.41739      23371.247      23371.247      925.49168      925.49168    
Loop time of 21.6936 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.983 ns/day, 6.026 hours/ns, 46.097 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    | 21.612     | 21.612     | 21.612     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.07
Output  | 4.8652e-05 | 4.8652e-05 | 4.8652e-05 |   0.0 |  0.00
Modify  | 0.061809   | 0.061809   | 0.061809   |   0.0 |  0.28
Other   |            | 0.005158   |            |       |  0.02

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

Total # of neighbors = 128158
Ave neighs/atom = 64.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.759570541763, Press = -1.08549413214005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8423.5441     -8423.5441     -8499.6189     -8499.6189      294.41739      294.41739      23371.247      23371.247      925.49168      925.49168    
     29000  -8428.6931     -8428.6931     -8502.4405     -8502.4405      285.41022      285.41022      23367.153      23367.153      605.38268      605.38268    
Loop time of 21.5823 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.003 ns/day, 5.995 hours/ns, 46.334 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    | 21.5       | 21.5       | 21.5       |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.07
Output  | 3.743e-05  | 3.743e-05  | 3.743e-05  |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.29
Other   |            | 0.005118   |            |       |  0.02

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

Total # of neighbors = 128226
Ave neighs/atom = 64.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704529684086, Press = -0.218222312338762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8428.6931     -8428.6931     -8502.4405     -8502.4405      285.41022      285.41022      23367.153      23367.153      605.38268      605.38268    
     30000  -8422.5888     -8422.5888     -8499.6126     -8499.6126      298.09006      298.09006      23366.94       23366.94       1310.5433      1310.5433    
Loop time of 21.5315 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.013 ns/day, 5.981 hours/ns, 46.444 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    | 21.45      | 21.45      | 21.45      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.07
Output  | 3.9904e-05 | 3.9904e-05 | 3.9904e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.29
Other   |            | 0.005192   |            |       |  0.02

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

Total # of neighbors = 128218
Ave neighs/atom = 64.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.663794738471, Press = 0.312848875056955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8422.5888     -8422.5888     -8499.6126     -8499.6126      298.09006      298.09006      23366.94       23366.94       1310.5433      1310.5433    
     31000  -8423.765      -8423.765      -8500.1982     -8500.1982      295.80435      295.80435      23341.086      23341.086      2941.7041      2941.7041    
Loop time of 21.6197 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.005 hours/ns, 46.254 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    | 21.538     | 21.538     | 21.538     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015112   | 0.015112   | 0.015112   |   0.0 |  0.07
Output  | 3.7951e-05 | 3.7951e-05 | 3.7951e-05 |   0.0 |  0.00
Modify  | 0.061769   | 0.061769   | 0.061769   |   0.0 |  0.29
Other   |            | 0.00518    |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.59483879193, Press = 0.765647825658632
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8423.765      -8423.765      -8500.1982     -8500.1982      295.80435      295.80435      23341.086      23341.086      2941.7041      2941.7041    
     32000  -8425.0571     -8425.0571     -8502.54       -8502.54        299.86684      299.86684      23326.486      23326.486      3797.8811      3797.8811    
Loop time of 21.5186 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.015 ns/day, 5.977 hours/ns, 46.472 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    | 21.437     | 21.437     | 21.437     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015006   | 0.015006   | 0.015006   |   0.0 |  0.07
Output  | 3.8573e-05 | 3.8573e-05 | 3.8573e-05 |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.29
Other   |            | 0.005151   |            |       |  0.02

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

Total # of neighbors = 128256
Ave neighs/atom = 64.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.526650868372, Press = 2.34379254206237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8425.0571     -8425.0571     -8502.54       -8502.54        299.86684      299.86684      23326.486      23326.486      3797.8811      3797.8811    
     33000  -8426.237      -8426.237      -8501.0203     -8501.0203      289.41916      289.41916      23355.401      23355.401      1766.7216      1766.7216    
Loop time of 21.5877 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.002 ns/day, 5.997 hours/ns, 46.323 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    | 21.506     | 21.506     | 21.506     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.07
Output  | 4.287e-05  | 4.287e-05  | 4.287e-05  |   0.0 |  0.00
Modify  | 0.061686   | 0.061686   | 0.061686   |   0.0 |  0.29
Other   |            | 0.005158   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.517069686169, Press = 2.49760024594386
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8426.237      -8426.237      -8501.0203     -8501.0203      289.41916      289.41916      23355.401      23355.401      1766.7216      1766.7216    
     34000  -8422.8713     -8422.8713     -8500.4659     -8500.4659      300.2991       300.2991       23382.733      23382.733      40.897241      40.897241    
Loop time of 21.5931 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.001 ns/day, 5.998 hours/ns, 46.311 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    | 21.511     | 21.511     | 21.511     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.07
Output  | 3.7119e-05 | 3.7119e-05 | 3.7119e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.29
Other   |            | 0.00514    |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.53596020808, Press = 2.92024944890956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8422.8713     -8422.8713     -8500.4659     -8500.4659      300.2991       300.2991       23382.733      23382.733      40.897241      40.897241    
     35000  -8423.4748     -8423.4748     -8500.6568     -8500.6568      298.70232      298.70232      23404.243      23404.243     -1584.1855     -1584.1855    
Loop time of 21.6501 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.991 ns/day, 6.014 hours/ns, 46.189 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    | 21.568     | 21.568     | 21.568     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.07
Output  | 3.735e-05  | 3.735e-05  | 3.735e-05  |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.29
Other   |            | 0.005129   |            |       |  0.02

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

Total # of neighbors = 128220
Ave neighs/atom = 64.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.533663011323, Press = 2.19749040973883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8423.4748     -8423.4748     -8500.6568     -8500.6568      298.70232      298.70232      23404.243      23404.243     -1584.1855     -1584.1855    
     36000  -8428.4828     -8428.4828     -8502.4743     -8502.4743      286.35505      286.35505      23402.988      23402.988     -1908.2653     -1908.2653    
Loop time of 21.6031 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.999 ns/day, 6.001 hours/ns, 46.290 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    | 21.521     | 21.521     | 21.521     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.07
Output  | 5.1156e-05 | 5.1156e-05 | 5.1156e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.29
Other   |            | 0.005124   |            |       |  0.02

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

Total # of neighbors = 128184
Ave neighs/atom = 64.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.507779178868, Press = 1.41359193940037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8428.4828     -8428.4828     -8502.4743     -8502.4743      286.35505      286.35505      23402.988      23402.988     -1908.2653     -1908.2653    
     37000  -8423.9465     -8423.9465     -8499.6047     -8499.6047      292.80526      292.80526      23429.035      23429.035     -3295.6719     -3295.6719    
Loop time of 21.5537 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.009 ns/day, 5.987 hours/ns, 46.396 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    | 21.472     | 21.472     | 21.472     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01497    | 0.01497    | 0.01497    |   0.0 |  0.07
Output  | 3.744e-05  | 3.744e-05  | 3.744e-05  |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.29
Other   |            | 0.005112   |            |       |  0.02

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

Total # of neighbors = 128166
Ave neighs/atom = 64.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.456614294205, Press = 0.220602860440773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8423.9465     -8423.9465     -8499.6047     -8499.6047      292.80526      292.80526      23429.035      23429.035     -3295.6719     -3295.6719    
     38000  -8429.0419     -8429.0419     -8501.4513     -8501.4513      280.23184      280.23184      23423.917      23423.917     -3349.8328     -3349.8328    
Loop time of 21.5934 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.001 ns/day, 5.998 hours/ns, 46.310 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    | 21.512     | 21.512     | 21.512     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.07
Output  | 3.8072e-05 | 3.8072e-05 | 3.8072e-05 |   0.0 |  0.00
Modify  | 0.06168    | 0.06168    | 0.06168    |   0.0 |  0.29
Other   |            | 0.005136   |            |       |  0.02

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.426194577791, Press = -1.24035418169348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8429.0419     -8429.0419     -8501.4513     -8501.4513      280.23184      280.23184      23423.917      23423.917     -3349.8328     -3349.8328    
     39000  -8424.0271     -8424.0271     -8498.3665     -8498.3665      287.70113      287.70113      23396.391      23396.391     -771.701       -771.701      
Loop time of 21.6049 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.999 ns/day, 6.001 hours/ns, 46.286 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    | 21.523     | 21.523     | 21.523     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.07
Output  | 4.7469e-05 | 4.7469e-05 | 4.7469e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.29
Other   |            | 0.00514    |            |       |  0.02

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

Total # of neighbors = 128198
Ave neighs/atom = 64.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.410392161665, Press = -0.304720772219644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8424.0271     -8424.0271     -8498.3665     -8498.3665      287.70113      287.70113      23396.391      23396.391     -771.701       -771.701      
     40000  -8422.9878     -8422.9878     -8500.3588     -8500.3588      299.43389      299.43389      23391.719      23391.719     -693.86464     -693.86464    
Loop time of 21.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.998 ns/day, 6.003 hours/ns, 46.273 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    | 21.529     | 21.529     | 21.529     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.07
Output  | 3.7711e-05 | 3.7711e-05 | 3.7711e-05 |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.29
Other   |            | 0.005118   |            |       |  0.02

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

Total # of neighbors = 128194
Ave neighs/atom = 64.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.439099648411, Press = -0.324711372325321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8422.9878     -8422.9878     -8500.3588     -8500.3588      299.43389      299.43389      23391.719      23391.719     -693.86464     -693.86464    
     41000  -8425.5627     -8425.5627     -8500.2412     -8500.2412      289.01329      289.01329      23374.237      23374.237      496.54806      496.54806    
Loop time of 21.5682 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.991 hours/ns, 46.365 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    | 21.486     | 21.486     | 21.486     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.07
Output  | 3.8181e-05 | 3.8181e-05 | 3.8181e-05 |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.29
Other   |            | 0.00516    |            |       |  0.02

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

Total # of neighbors = 128170
Ave neighs/atom = 64.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.477004433563, Press = -0.451479567656752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8425.5627     -8425.5627     -8500.2412     -8500.2412      289.01329      289.01329      23374.237      23374.237      496.54806      496.54806    
     42000  -8424.0182     -8424.0182     -8498.87       -8498.87        289.68403      289.68403      23355.214      23355.214      2069.5677      2069.5677    
Loop time of 21.5447 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.010 ns/day, 5.985 hours/ns, 46.415 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    | 21.463     | 21.463     | 21.463     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.07
Output  | 4.7079e-05 | 4.7079e-05 | 4.7079e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.29
Other   |            | 0.00516    |            |       |  0.02

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

Total # of neighbors = 128186
Ave neighs/atom = 64.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.454347479611, Press = -0.629448516001215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8424.0182     -8424.0182     -8498.87       -8498.87        289.68403      289.68403      23355.214      23355.214      2069.5677      2069.5677    
     43000  -8429.6895     -8429.6895     -8503.7758     -8503.7758      286.7214       286.7214       23347.206      23347.206      1981.0476      1981.0476    
Loop time of 21.6033 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.999 ns/day, 6.001 hours/ns, 46.289 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    | 21.521     | 21.521     | 21.521     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01498    | 0.01498    | 0.01498    |   0.0 |  0.07
Output  | 3.9444e-05 | 3.9444e-05 | 3.9444e-05 |   0.0 |  0.00
Modify  | 0.061802   | 0.061802   | 0.061802   |   0.0 |  0.29
Other   |            | 0.005177   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.447129095852, Press = 0.22327535792194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8429.6895     -8429.6895     -8503.7758     -8503.7758      286.7214       286.7214       23347.206      23347.206      1981.0476      1981.0476    
     44000  -8423.4787     -8423.4787     -8498.8186     -8498.8186      291.57343      291.57343      23369.866      23369.866      1052.2224      1052.2224    
Loop time of 21.4511 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.028 ns/day, 5.959 hours/ns, 46.618 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    | 21.369     | 21.369     | 21.369     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.07
Output  | 4.7559e-05 | 4.7559e-05 | 4.7559e-05 |   0.0 |  0.00
Modify  | 0.062028   | 0.062028   | 0.062028   |   0.0 |  0.29
Other   |            | 0.005299   |            |       |  0.02

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

Total # of neighbors = 128184
Ave neighs/atom = 64.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.420405359415, Press = 1.0482002016738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8423.4787     -8423.4787     -8498.8186     -8498.8186      291.57343      291.57343      23369.866      23369.866      1052.2224      1052.2224    
     45000  -8422.0818     -8422.0818     -8499.3815     -8499.3815      299.15799      299.15799      23375.421      23375.421      685.71884      685.71884    
Loop time of 21.6378 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.993 ns/day, 6.011 hours/ns, 46.215 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    | 21.556     | 21.556     | 21.556     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.07
Output  | 4.244e-05  | 4.244e-05  | 4.244e-05  |   0.0 |  0.00
Modify  | 0.06191    | 0.06191    | 0.06191    |   0.0 |  0.29
Other   |            | 0.005226   |            |       |  0.02

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

Total # of neighbors = 128196
Ave neighs/atom = 64.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.493090088475, Press = 0.879809113001403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8422.0818     -8422.0818     -8499.3815     -8499.3815      299.15799      299.15799      23375.421      23375.421      685.71884      685.71884    
     46000  -8423.6577     -8423.6577     -8500.8672     -8500.8672      298.80881      298.80881      23379.381      23379.381      209.98459      209.98459    
Loop time of 21.7222 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.034 hours/ns, 46.036 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    | 21.64      | 21.64      | 21.64      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.07
Output  | 4.793e-05  | 4.793e-05  | 4.793e-05  |   0.0 |  0.00
Modify  | 0.061955   | 0.061955   | 0.061955   |   0.0 |  0.29
Other   |            | 0.005198   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.528418907175, Press = 1.51648292697978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8423.6577     -8423.6577     -8500.8672     -8500.8672      298.80881      298.80881      23379.381      23379.381      209.98459      209.98459    
     47000  -8425.2718     -8425.2718     -8501.336      -8501.336       294.37614      294.37614      23396.839      23396.839     -1234.8715     -1234.8715    
Loop time of 21.6483 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.991 ns/day, 6.013 hours/ns, 46.193 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    | 21.566     | 21.566     | 21.566     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.07
Output  | 4.76e-05   | 4.76e-05   | 4.76e-05   |   0.0 |  0.00
Modify  | 0.061701   | 0.061701   | 0.061701   |   0.0 |  0.29
Other   |            | 0.005138   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.561514233631, Press = 3.62598055688697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8425.2718     -8425.2718     -8501.336      -8501.336       294.37614      294.37614      23396.839      23396.839     -1234.8715     -1234.8715    
     48000  -8422.5781     -8422.5781     -8500.347      -8500.347       300.97369      300.97369      23414.457      23414.457     -2213.8945     -2213.8945    
Loop time of 21.5527 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.009 ns/day, 5.987 hours/ns, 46.398 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    | 21.471     | 21.471     | 21.471     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015045   | 0.015045   | 0.015045   |   0.0 |  0.07
Output  | 0.00019441 | 0.00019441 | 0.00019441 |   0.0 |  0.00
Modify  | 0.061763   | 0.061763   | 0.061763   |   0.0 |  0.29
Other   |            | 0.005162   |            |       |  0.02

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.595586612938, Press = 2.5903848047382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8422.5781     -8422.5781     -8500.347      -8500.347       300.97369      300.97369      23414.457      23414.457     -2213.8945     -2213.8945    
     49000  -8423.3831     -8423.3831     -8498.4837     -8498.4837      290.64738      290.64738      23403.008      23403.008     -1303.1221     -1303.1221    
Loop time of 21.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.019 ns/day, 5.972 hours/ns, 46.512 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    | 21.418     | 21.418     | 21.418     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015059   | 0.015059   | 0.015059   |   0.0 |  0.07
Output  | 5.1707e-05 | 5.1707e-05 | 5.1707e-05 |   0.0 |  0.00
Modify  | 0.061872   | 0.061872   | 0.061872   |   0.0 |  0.29
Other   |            | 0.005214   |            |       |  0.02

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

Total # of neighbors = 128118
Ave neighs/atom = 64.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.627096415734, Press = 1.40627021894101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8423.3831     -8423.3831     -8498.4837     -8498.4837      290.64738      290.64738      23403.008      23403.008     -1303.1221     -1303.1221    
     50000  -8424.9926     -8424.9926     -8498.8793     -8498.8793      285.94931      285.94931      23392.723      23392.723     -608.07229     -608.07229    
Loop time of 21.6339 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.994 ns/day, 6.009 hours/ns, 46.224 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    | 21.552     | 21.552     | 21.552     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015017   | 0.015017   | 0.015017   |   0.0 |  0.07
Output  | 4.3331e-05 | 4.3331e-05 | 4.3331e-05 |   0.0 |  0.00
Modify  | 0.06163    | 0.06163    | 0.06163    |   0.0 |  0.28
Other   |            | 0.005224   |            |       |  0.02

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.710515900336, Press = 1.14811645329067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8424.9926     -8424.9926     -8498.8793     -8498.8793      285.94931      285.94931      23392.723      23392.723     -608.07229     -608.07229    
     51000  -8425.1184     -8425.1184     -8499.5753     -8499.5753      288.15612      288.15612      23403.37       23403.37      -1504.3959     -1504.3959    
Loop time of 21.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.991 hours/ns, 46.365 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    | 21.486     | 21.486     | 21.486     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015022   | 0.015022   | 0.015022   |   0.0 |  0.07
Output  | 3.9895e-05 | 3.9895e-05 | 3.9895e-05 |   0.0 |  0.00
Modify  | 0.061698   | 0.061698   | 0.061698   |   0.0 |  0.29
Other   |            | 0.005092   |            |       |  0.02

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

Total # of neighbors = 128214
Ave neighs/atom = 64.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.744681307493, Press = 0.654848938911024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8425.1184     -8425.1184     -8499.5753     -8499.5753      288.15612      288.15612      23403.37       23403.37      -1504.3959     -1504.3959    
     52000  -8427.2569     -8427.2569     -8502.7809     -8502.7809      292.28586      292.28586      23426.608      23426.608     -3509.7866     -3509.7866    
Loop time of 21.6216 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.006 hours/ns, 46.250 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    | 21.539     | 21.539     | 21.539     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015144   | 0.015144   | 0.015144   |   0.0 |  0.07
Output  | 8.3186e-05 | 8.3186e-05 | 8.3186e-05 |   0.0 |  0.00
Modify  | 0.062009   | 0.062009   | 0.062009   |   0.0 |  0.29
Other   |            | 0.005222   |            |       |  0.02

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

Total # of neighbors = 128214
Ave neighs/atom = 64.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.767255073452, Press = -0.713025040482846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8427.2569     -8427.2569     -8502.7809     -8502.7809      292.28586      292.28586      23426.608      23426.608     -3509.7866     -3509.7866    
     53000  -8423.7923     -8423.7923     -8498.8732     -8498.8732      290.57086      290.57086      23407.245      23407.245     -1596.0297     -1596.0297    
Loop time of 21.6305 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.994 ns/day, 6.008 hours/ns, 46.231 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    | 21.549     | 21.549     | 21.549     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.07
Output  | 4.309e-05  | 4.309e-05  | 4.309e-05  |   0.0 |  0.00
Modify  | 0.061734   | 0.061734   | 0.061734   |   0.0 |  0.29
Other   |            | 0.005119   |            |       |  0.02

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

Total # of neighbors = 128162
Ave neighs/atom = 64.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.730237340845, Press = -0.65871448630829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8423.7923     -8423.7923     -8498.8732     -8498.8732      290.57086      290.57086      23407.245      23407.245     -1596.0297     -1596.0297    
     54000  -8427.5224     -8427.5224     -8502.0197     -8502.0197      288.31231      288.31231      23384.568      23384.568     -312.25104     -312.25104    
Loop time of 21.5466 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.010 ns/day, 5.985 hours/ns, 46.411 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    | 21.464     | 21.464     | 21.464     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015335   | 0.015335   | 0.015335   |   0.0 |  0.07
Output  | 5.32e-05   | 5.32e-05   | 5.32e-05   |   0.0 |  0.00
Modify  | 0.06224    | 0.06224    | 0.06224    |   0.0 |  0.29
Other   |            | 0.005248   |            |       |  0.02

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

Total # of neighbors = 128190
Ave neighs/atom = 64.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.709700871362, Press = -0.303762950073772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8427.5224     -8427.5224     -8502.0197     -8502.0197      288.31231      288.31231      23384.568      23384.568     -312.25104     -312.25104    
     55000  -8424.7279     -8424.7279     -8500.0466     -8500.0466      291.49121      291.49121      23372.833      23372.833      716.60869      716.60869    
Loop time of 21.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.017 ns/day, 5.975 hours/ns, 46.488 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    | 21.428     | 21.428     | 21.428     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015233   | 0.015233   | 0.015233   |   0.0 |  0.07
Output  | 0.00012073 | 0.00012073 | 0.00012073 |   0.0 |  0.00
Modify  | 0.061912   | 0.061912   | 0.061912   |   0.0 |  0.29
Other   |            | 0.005219   |            |       |  0.02

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

Total # of neighbors = 128194
Ave neighs/atom = 64.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.666456732948, Press = -0.112448974023293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8424.7279     -8424.7279     -8500.0466     -8500.0466      291.49121      291.49121      23372.833      23372.833      716.60869      716.60869    
     56000  -8426.5751     -8426.5751     -8500.6207     -8500.6207      286.56399      286.56399      23360.026      23360.026      1536.7912      1536.7912    
Loop time of 21.5813 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.003 ns/day, 5.995 hours/ns, 46.336 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    | 21.499     | 21.499     | 21.499     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015069   | 0.015069   | 0.015069   |   0.0 |  0.07
Output  | 4.78e-05   | 4.78e-05   | 4.78e-05   |   0.0 |  0.00
Modify  | 0.061753   | 0.061753   | 0.061753   |   0.0 |  0.29
Other   |            | 0.00516    |            |       |  0.02

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

Total # of neighbors = 128230
Ave neighs/atom = 64.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.673771223585, Press = -0.0722584889028734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8426.5751     -8426.5751     -8500.6207     -8500.6207      286.56399      286.56399      23360.026      23360.026      1536.7912      1536.7912    
     57000  -8423.5359     -8423.5359     -8502.3515     -8502.3515      305.02459      305.02459      23368.178      23368.178      776.37542      776.37542    
Loop time of 21.5666 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.991 hours/ns, 46.368 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    | 21.485     | 21.485     | 21.485     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.07
Output  | 4.6978e-05 | 4.6978e-05 | 4.6978e-05 |   0.0 |  0.00
Modify  | 0.061735   | 0.061735   | 0.061735   |   0.0 |  0.29
Other   |            | 0.00516    |            |       |  0.02

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

Total # of neighbors = 128218
Ave neighs/atom = 64.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.627927600742, Press = 0.352981106079973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8423.5359     -8423.5359     -8502.3515     -8502.3515      305.02459      305.02459      23368.178      23368.178      776.37542      776.37542    
     58000  -8425.9525     -8425.9525     -8502.1548     -8502.1548      294.91048      294.91048      23367.971      23367.971      635.06664      635.06664    
Loop time of 21.6506 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.991 ns/day, 6.014 hours/ns, 46.188 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    | 21.569     | 21.569     | 21.569     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.07
Output  | 3.748e-05  | 3.748e-05  | 3.748e-05  |   0.0 |  0.00
Modify  | 0.061595   | 0.061595   | 0.061595   |   0.0 |  0.28
Other   |            | 0.005142   |            |       |  0.02

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

Total # of neighbors = 128204
Ave neighs/atom = 64.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.648740284776, Press = 0.892080213787186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8425.9525     -8425.9525     -8502.1548     -8502.1548      294.91048      294.91048      23367.971      23367.971      635.06664      635.06664    
     59000  -8423.841      -8423.841      -8499.8709     -8499.8709      294.24377      294.24377      23365.281      23365.281      1321.7856      1321.7856    
Loop time of 21.5849 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.003 ns/day, 5.996 hours/ns, 46.329 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    | 21.503     | 21.503     | 21.503     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015056   | 0.015056   | 0.015056   |   0.0 |  0.07
Output  | 4.5295e-05 | 4.5295e-05 | 4.5295e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.29
Other   |            | 0.005132   |            |       |  0.02

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

Total # of neighbors = 128210
Ave neighs/atom = 64.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704988971252, Press = 1.0197801042459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8423.841      -8423.841      -8499.8709     -8499.8709      294.24377      294.24377      23365.281      23365.281      1321.7856      1321.7856    
     60000  -8425.0369     -8425.0369     -8499.0228     -8499.0228      286.33302      286.33302      23352.689      23352.689      2240.6129      2240.6129    
Loop time of 21.4581 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.026 ns/day, 5.961 hours/ns, 46.602 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    | 21.376     | 21.376     | 21.376     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015005   | 0.015005   | 0.015005   |   0.0 |  0.07
Output  | 3.748e-05  | 3.748e-05  | 3.748e-05  |   0.0 |  0.00
Modify  | 0.061579   | 0.061579   | 0.061579   |   0.0 |  0.29
Other   |            | 0.00511    |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.738522624785, Press = 1.29782947676176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8425.0369     -8425.0369     -8499.0228     -8499.0228      286.33302      286.33302      23352.689      23352.689      2240.6129      2240.6129    
     61000  -8423.8196     -8423.8196     -8499.3074     -8499.3074      292.14577      292.14577      23348.811      23348.811      2646.4771      2646.4771    
Loop time of 21.4882 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.021 ns/day, 5.969 hours/ns, 46.537 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    | 21.406     | 21.406     | 21.406     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.07
Output  | 3.73e-05   | 3.73e-05   | 3.73e-05   |   0.0 |  0.00
Modify  | 0.061526   | 0.061526   | 0.061526   |   0.0 |  0.29
Other   |            | 0.005278   |            |       |  0.02

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.778555183264, Press = 2.73880814549842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8423.8196     -8423.8196     -8499.3074     -8499.3074      292.14577      292.14577      23348.811      23348.811      2646.4771      2646.4771    
     62000  -8421.2201     -8421.2201     -8499.0323     -8499.0323      301.14148      301.14148      23386.174      23386.174     -20.805487     -20.805487    
Loop time of 21.5294 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.013 ns/day, 5.980 hours/ns, 46.448 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    | 21.448     | 21.448     | 21.448     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.07
Output  | 4.3221e-05 | 4.3221e-05 | 4.3221e-05 |   0.0 |  0.00
Modify  | 0.061529   | 0.061529   | 0.061529   |   0.0 |  0.29
Other   |            | 0.005131   |            |       |  0.02

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

Total # of neighbors = 128264
Ave neighs/atom = 64.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.773435027406, Press = 2.12102340196811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8421.2201     -8421.2201     -8499.0323     -8499.0323      301.14148      301.14148      23386.174      23386.174     -20.805487     -20.805487    
     63000  -8425.8724     -8425.8724     -8499.9833     -8499.9833      286.81662      286.81662      23387.359      23387.359     -433.69858     -433.69858    
Loop time of 21.6699 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.987 ns/day, 6.019 hours/ns, 46.147 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    | 21.588     | 21.588     | 21.588     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014947   | 0.014947   | 0.014947   |   0.0 |  0.07
Output  | 3.725e-05  | 3.725e-05  | 3.725e-05  |   0.0 |  0.00
Modify  | 0.061509   | 0.061509   | 0.061509   |   0.0 |  0.28
Other   |            | 0.005119   |            |       |  0.02

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

Total # of neighbors = 128246
Ave neighs/atom = 64.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.802281256561, Press = 1.69520026699953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8425.8724     -8425.8724     -8499.9833     -8499.9833      286.81662      286.81662      23387.359      23387.359     -433.69858     -433.69858    
     64000  -8420.9353     -8420.9353     -8498.9307     -8498.9307      301.85022      301.85022      23398.753      23398.753     -839.65208     -839.65208    
Loop time of 21.6209 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.006 hours/ns, 46.251 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    | 21.539     | 21.539     | 21.539     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.07
Output  | 4.1318e-05 | 4.1318e-05 | 4.1318e-05 |   0.0 |  0.00
Modify  | 0.061469   | 0.061469   | 0.061469   |   0.0 |  0.28
Other   |            | 0.005139   |            |       |  0.02

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

Total # of neighbors = 128210
Ave neighs/atom = 64.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.857589581335, Press = 1.4116618256709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8420.9353     -8420.9353     -8498.9307     -8498.9307      301.85022      301.85022      23398.753      23398.753     -839.65208     -839.65208    
     65000  -8426.2397     -8426.2397     -8501.6202     -8501.6202      291.73046      291.73046      23409.544      23409.544     -2212.3133     -2212.3133    
Loop time of 21.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.006 hours/ns, 46.247 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    | 21.541     | 21.541     | 21.541     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.07
Output  | 3.8422e-05 | 3.8422e-05 | 3.8422e-05 |   0.0 |  0.00
Modify  | 0.061456   | 0.061456   | 0.061456   |   0.0 |  0.28
Other   |            | 0.005184   |            |       |  0.02

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

Total # of neighbors = 128250
Ave neighs/atom = 64.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.873997669601, Press = 1.08754230914562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8426.2397     -8426.2397     -8501.6202     -8501.6202      291.73046      291.73046      23409.544      23409.544     -2212.3133     -2212.3133    
     66000  -8421.6584     -8421.6584     -8498.3587     -8498.3587      296.83812      296.83812      23433.874      23433.874     -3498.6951     -3498.6951    
Loop time of 21.5238 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.014 ns/day, 5.979 hours/ns, 46.460 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    | 21.442     | 21.442     | 21.442     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014891   | 0.014891   | 0.014891   |   0.0 |  0.07
Output  | 3.6048e-05 | 3.6048e-05 | 3.6048e-05 |   0.0 |  0.00
Modify  | 0.061524   | 0.061524   | 0.061524   |   0.0 |  0.29
Other   |            | 0.005117   |            |       |  0.02

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

Total # of neighbors = 128158
Ave neighs/atom = 64.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.913737758455, Press = 0.359878621914995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8421.6584     -8421.6584     -8498.3587     -8498.3587      296.83812      296.83812      23433.874      23433.874     -3498.6951     -3498.6951    
     67000  -8422.6041     -8422.6041     -8499.8407     -8499.8407      298.91393      298.91393      23425.202      23425.202     -2894.3943     -2894.3943    
Loop time of 21.5662 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.991 hours/ns, 46.369 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    | 21.485     | 21.485     | 21.485     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014911   | 0.014911   | 0.014911   |   0.0 |  0.07
Output  | 4.284e-05  | 4.284e-05  | 4.284e-05  |   0.0 |  0.00
Modify  | 0.061533   | 0.061533   | 0.061533   |   0.0 |  0.29
Other   |            | 0.005121   |            |       |  0.02

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926558160882, Press = -0.506574488624023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8422.6041     -8422.6041     -8499.8407     -8499.8407      298.91393      298.91393      23425.202      23425.202     -2894.3943     -2894.3943    
     68000  -8427.6562     -8427.6562     -8502.4728     -8502.4728      289.54805      289.54805      23383.649      23383.649     -387.40695     -387.40695    
Loop time of 21.5231 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.014 ns/day, 5.979 hours/ns, 46.462 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.442     | 21.442     | 21.442     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.07
Output  | 3.5787e-05 | 3.5787e-05 | 3.5787e-05 |   0.0 |  0.00
Modify  | 0.061533   | 0.061533   | 0.061533   |   0.0 |  0.29
Other   |            | 0.005126   |            |       |  0.02

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

Total # of neighbors = 128186
Ave neighs/atom = 64.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896591556458, Press = 0.119548631171096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8427.6562     -8427.6562     -8502.4728     -8502.4728      289.54805      289.54805      23383.649      23383.649     -387.40695     -387.40695    
     69000  -8422.5885     -8422.5885     -8498.2664     -8498.2664      292.88138      292.88138      23382.873      23382.873      174.53518      174.53518    
Loop time of 21.5109 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.017 ns/day, 5.975 hours/ns, 46.488 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    | 21.429     | 21.429     | 21.429     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.07
Output  | 4.0506e-05 | 4.0506e-05 | 4.0506e-05 |   0.0 |  0.00
Modify  | 0.061438   | 0.061438   | 0.061438   |   0.0 |  0.29
Other   |            | 0.005118   |            |       |  0.02

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896873445371, Press = 0.405199217495474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8422.5885     -8422.5885     -8498.2664     -8498.2664      292.88138      292.88138      23382.873      23382.873      174.53518      174.53518    
     70000  -8426.3987     -8426.3987     -8500.9961     -8500.9961      288.69993      288.69993      23378.577      23378.577      116.22958      116.22958    
Loop time of 21.5148 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.016 ns/day, 5.976 hours/ns, 46.480 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    | 21.432     | 21.432     | 21.432     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.07
Output  | 4.4013e-05 | 4.4013e-05 | 4.4013e-05 |   0.0 |  0.00
Modify  | 0.062281   | 0.062281   | 0.062281   |   0.0 |  0.29
Other   |            | 0.005125   |            |       |  0.02

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

Total # of neighbors = 128198
Ave neighs/atom = 64.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914751687836, Press = 0.498895578054668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8426.3987     -8426.3987     -8500.9961     -8500.9961      288.69993      288.69993      23378.577      23378.577      116.22958      116.22958    
     71000  -8423.3757     -8423.3757     -8499.5874     -8499.5874      294.94721      294.94721      23383.216      23383.216      70.137543      70.137543    
Loop time of 21.5123 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.016 ns/day, 5.976 hours/ns, 46.485 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    | 21.431     | 21.431     | 21.431     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.07
Output  | 3.6699e-05 | 3.6699e-05 | 3.6699e-05 |   0.0 |  0.00
Modify  | 0.061412   | 0.061412   | 0.061412   |   0.0 |  0.29
Other   |            | 0.005136   |            |       |  0.02

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0