# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.6150126680731782*${_u_distance}
variable latticeconst_converted equal 3.6150126680731782*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61501266807318
Lattice spacing in x,y,z = 3.6150127 3.6150127 3.6150127
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.150127 36.150127 36.150127)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.150127 36.150127 36.150127)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_AgrawalMirzaeifar_2021_CuC__MO_028979335952_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13987.791     -13987.791     -14160         -14160          333.15         333.15         47242.13       47242.13       3893.5646      3893.5646    
      1000  -13811.996     -13811.996     -13989.679     -13989.679      343.73914      343.73914      47940.309      47940.309      284.28292      284.28292    
Loop time of 567.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.152 ns/day, 157.549 hours/ns, 1.763 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 566.24     | 566.24     | 566.24     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14605    | 0.14605    | 0.14605    |   0.0 |  0.03
Output  | 0.00034319 | 0.00034319 | 0.00034319 |   0.0 |  0.00
Modify  | 0.68636    | 0.68636    | 0.68636    |   0.0 |  0.12
Other   |            | 0.09968    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13811.996     -13811.996     -13989.679     -13989.679      343.73914      343.73914      47940.309      47940.309      284.28292      284.28292    
      2000  -13820.728     -13820.728     -13997.151     -13997.151      341.30121      341.30121      47965.997      47965.997     -1223.4667     -1223.4667    
Loop time of 581.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 161.629 hours/ns, 1.719 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.91     | 580.91     | 580.91     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14777    | 0.14777    | 0.14777    |   0.0 |  0.03
Output  | 0.00022877 | 0.00022877 | 0.00022877 |   0.0 |  0.00
Modify  | 0.70512    | 0.70512    | 0.70512    |   0.0 |  0.12
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530548 ave      530548 max      530548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530548
Ave neighs/atom = 132.637
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13820.728     -13820.728     -13997.151     -13997.151      341.30121      341.30121      47965.997      47965.997     -1223.4667     -1223.4667    
      3000  -13817.052     -13817.052     -13988.646     -13988.646      331.95873      331.95873      47953.979      47953.979     -259.59245     -259.59245    
Loop time of 583.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.171 hours/ns, 1.713 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.87     | 582.87     | 582.87     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14711    | 0.14711    | 0.14711    |   0.0 |  0.03
Output  | 0.00022822 | 0.00022822 | 0.00022822 |   0.0 |  0.00
Modify  | 0.70066    | 0.70066    | 0.70066    |   0.0 |  0.12
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       531490 ave      531490 max      531490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531490
Ave neighs/atom = 132.8725
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13817.052     -13817.052     -13988.646     -13988.646      331.95873      331.95873      47953.979      47953.979     -259.59245     -259.59245    
      4000  -13820.35      -13820.35      -13989.634     -13989.634      327.49133      327.49133      47914.138      47914.138      725.86887      725.86887    
Loop time of 583.327 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.035 hours/ns, 1.714 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.38     | 582.38     | 582.38     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14792    | 0.14792    | 0.14792    |   0.0 |  0.03
Output  | 0.00023584 | 0.00023584 | 0.00023584 |   0.0 |  0.00
Modify  | 0.69893    | 0.69893    | 0.69893    |   0.0 |  0.12
Other   |            | 0.1008     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530404 ave      530404 max      530404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530404
Ave neighs/atom = 132.601
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13820.35      -13820.35      -13989.634     -13989.634      327.49133      327.49133      47914.138      47914.138      725.86887      725.86887    
      5000  -13816.943     -13816.943     -13991.639     -13991.639      337.96045      337.96045      47900.714      47900.714      1096.1476      1096.1476    
Loop time of 578.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.149 ns/day, 160.676 hours/ns, 1.729 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.48     | 577.48     | 577.48     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14765    | 0.14765    | 0.14765    |   0.0 |  0.03
Output  | 0.00029732 | 0.00029732 | 0.00029732 |   0.0 |  0.00
Modify  | 0.70009    | 0.70009    | 0.70009    |   0.0 |  0.12
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 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:       531178 ave      531178 max      531178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531178
Ave neighs/atom = 132.7945
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 = 336.133160847045, Press = -33.4344240107941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13816.943     -13816.943     -13991.639     -13991.639      337.96045      337.96045      47900.714      47900.714      1096.1476      1096.1476    
      6000  -13819.242     -13819.242     -13989.437     -13989.437      329.25297      329.25297      47918.861      47918.861      666.10217      666.10217    
Loop time of 589.333 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.704 hours/ns, 1.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 588.34     | 588.34     | 588.34     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14966    | 0.14966    | 0.14966    |   0.0 |  0.03
Output  | 0.0002414  | 0.0002414  | 0.0002414  |   0.0 |  0.00
Modify  | 0.73784    | 0.73784    | 0.73784    |   0.0 |  0.13
Other   |            | 0.1023     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 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:       531138 ave      531138 max      531138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531138
Ave neighs/atom = 132.7845
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 = 332.423132819709, Press = 44.378910716431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13819.242     -13819.242     -13989.437     -13989.437      329.25297      329.25297      47918.861      47918.861      666.10217      666.10217    
      7000  -13819.611     -13819.611     -13990.985     -13990.985      331.53593      331.53593      47991.435      47991.435     -1553.68       -1553.68      
Loop time of 586.8 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.000 hours/ns, 1.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.81     | 585.81     | 585.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1503     | 0.1503     | 0.1503     |   0.0 |  0.03
Output  | 0.00019719 | 0.00019719 | 0.00019719 |   0.0 |  0.00
Modify  | 0.74278    | 0.74278    | 0.74278    |   0.0 |  0.13
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530702 ave      530702 max      530702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530702
Ave neighs/atom = 132.6755
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 = 333.20661838725, Press = 13.6180991198961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13819.611     -13819.611     -13990.985     -13990.985      331.53593      331.53593      47991.435      47991.435     -1553.68       -1553.68      
      8000  -13815.337     -13815.337     -13990.645     -13990.645      339.14425      339.14425      48023.55       48023.55      -2349.4889     -2349.4889    
Loop time of 588.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.478 hours/ns, 1.699 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.52     | 587.52     | 587.52     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.03
Output  | 0.00023723 | 0.00023723 | 0.00023723 |   0.0 |  0.00
Modify  | 0.74343    | 0.74343    | 0.74343    |   0.0 |  0.13
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530652 ave      530652 max      530652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530652
Ave neighs/atom = 132.663
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 = 333.182409974874, Press = -11.5331489839039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13815.337     -13815.337     -13990.645     -13990.645      339.14425      339.14425      48023.55       48023.55      -2349.4889     -2349.4889    
      9000  -13820.919     -13820.919     -13993.53      -13993.53       333.9284       333.9284       47941.973      47941.973     -289.92496     -289.92496    
Loop time of 592.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.146 ns/day, 164.537 hours/ns, 1.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 591.34     | 591.34     | 591.34     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14918    | 0.14918    | 0.14918    |   0.0 |  0.03
Output  | 0.00023813 | 0.00023813 | 0.00023813 |   0.0 |  0.00
Modify  | 0.74221    | 0.74221    | 0.74221    |   0.0 |  0.13
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530324 ave      530324 max      530324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530324
Ave neighs/atom = 132.581
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 = 333.262551748573, Press = -11.7141192244591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13820.919     -13820.919     -13993.53      -13993.53       333.9284       333.9284       47941.973      47941.973     -289.92496     -289.92496    
     10000  -13816.002     -13816.002     -13991.235     -13991.235      339.00007      339.00007      47919.393      47919.393      614.86108      614.86108    
Loop time of 586.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 162.826 hours/ns, 1.706 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.19     | 585.19     | 585.19     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14957    | 0.14957    | 0.14957    |   0.0 |  0.03
Output  | 0.00019383 | 0.00019383 | 0.00019383 |   0.0 |  0.00
Modify  | 0.73424    | 0.73424    | 0.73424    |   0.0 |  0.13
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 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:       531300 ave      531300 max      531300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531300
Ave neighs/atom = 132.825
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 = 333.637973244364, Press = -3.36505510981349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13816.002     -13816.002     -13991.235     -13991.235      339.00007      339.00007      47919.393      47919.393      614.86108      614.86108    
     11000  -13818.459     -13818.459     -13990.173     -13990.173      332.19303      332.19303      47904.89       47904.89       1022.8105      1022.8105    
Loop time of 589.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.790 hours/ns, 1.696 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 588.65     | 588.65     | 588.65     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14969    | 0.14969    | 0.14969    |   0.0 |  0.03
Output  | 0.00019459 | 0.00019459 | 0.00019459 |   0.0 |  0.00
Modify  | 0.74475    | 0.74475    | 0.74475    |   0.0 |  0.13
Other   |            | 0.1025     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530934 ave      530934 max      530934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530934
Ave neighs/atom = 132.7335
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 = 333.646325044892, Press = 2.37163758338621
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13818.459     -13818.459     -13990.173     -13990.173      332.19303      332.19303      47904.89       47904.89       1022.8105      1022.8105    
     12000  -13815.965     -13815.965     -13992.617     -13992.617      341.74568      341.74568      47938.861      47938.861     -40.815975     -40.815975    
Loop time of 586.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.010 hours/ns, 1.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.85     | 585.85     | 585.85     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14808    | 0.14808    | 0.14808    |   0.0 |  0.03
Output  | 0.00024641 | 0.00024641 | 0.00024641 |   0.0 |  0.00
Modify  | 0.7327     | 0.7327     | 0.7327     |   0.0 |  0.12
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530890 ave      530890 max      530890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530890
Ave neighs/atom = 132.7225
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 = 333.59053301973, Press = 3.3687703694027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13815.965     -13815.965     -13992.617     -13992.617      341.74568      341.74568      47938.861      47938.861     -40.815975     -40.815975    
     13000  -13821.818     -13821.818     -13991.144     -13991.144      327.57261      327.57261      47964.467      47964.467     -869.45814     -869.45814    
Loop time of 589.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.737 hours/ns, 1.696 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 588.47     | 588.47     | 588.47     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14792    | 0.14792    | 0.14792    |   0.0 |  0.03
Output  | 0.00029228 | 0.00029228 | 0.00029228 |   0.0 |  0.00
Modify  | 0.73373    | 0.73373    | 0.73373    |   0.0 |  0.12
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 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:       530964 ave      530964 max      530964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530964
Ave neighs/atom = 132.741
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 = 333.384730478634, Press = 3.61139616351145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13821.818     -13821.818     -13991.144     -13991.144      327.57261      327.57261      47964.467      47964.467     -869.45814     -869.45814    
     14000  -13815.457     -13815.457     -13988.679     -13988.679      335.10911      335.10911      48028.101      48028.101     -2352.7752     -2352.7752    
Loop time of 585.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.657 hours/ns, 1.708 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.58     | 584.58     | 584.58     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14882    | 0.14882    | 0.14882    |   0.0 |  0.03
Output  | 0.0011828  | 0.0011828  | 0.0011828  |   0.0 |  0.00
Modify  | 0.73499    | 0.73499    | 0.73499    |   0.0 |  0.13
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530674 ave      530674 max      530674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530674
Ave neighs/atom = 132.6685
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 = 333.43695343349, Press = -3.45163217837715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13815.457     -13815.457     -13988.679     -13988.679      335.10911      335.10911      48028.101      48028.101     -2352.7752     -2352.7752    
     15000  -13818.608     -13818.608     -13988.856     -13988.856      329.35674      329.35674      47939.853      47939.853      148.49265      148.49265    
Loop time of 588.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.425 hours/ns, 1.700 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.34     | 587.34     | 587.34     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14906    | 0.14906    | 0.14906    |   0.0 |  0.03
Output  | 0.00030718 | 0.00030718 | 0.00030718 |   0.0 |  0.00
Modify  | 0.74096    | 0.74096    | 0.74096    |   0.0 |  0.13
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530116 ave      530116 max      530116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530116
Ave neighs/atom = 132.529
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 = 333.36643073364, Press = -5.65010374068653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13818.608     -13818.608     -13988.856     -13988.856      329.35674      329.35674      47939.853      47939.853      148.49265      148.49265    
     16000  -13816.573     -13816.573     -13990.047     -13990.047      335.59675      335.59675      47908.015      47908.015      940.94418      940.94418    
Loop time of 586.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 162.849 hours/ns, 1.706 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.27     | 585.27     | 585.27     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15041    | 0.15041    | 0.15041    |   0.0 |  0.03
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.737      | 0.737      | 0.737      |   0.0 |  0.13
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530850 ave      530850 max      530850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530850
Ave neighs/atom = 132.7125
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 = 333.443251511891, Press = -1.05670951406309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13816.573     -13816.573     -13990.047     -13990.047      335.59675      335.59675      47908.015      47908.015      940.94418      940.94418    
     17000  -13819.696     -13819.696     -13990.564     -13990.564      330.55563      330.55563      47916.099      47916.099      583.28274      583.28274    
Loop time of 587.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.099 hours/ns, 1.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.16     | 586.16     | 586.16     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15036    | 0.15036    | 0.15036    |   0.0 |  0.03
Output  | 0.00019118 | 0.00019118 | 0.00019118 |   0.0 |  0.00
Modify  | 0.73799    | 0.73799    | 0.73799    |   0.0 |  0.13
Other   |            | 0.1023     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5847 ave        5847 max        5847 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:       530978 ave      530978 max      530978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530978
Ave neighs/atom = 132.7445
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 = 333.554703017276, Press = 1.06864592140378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13819.696     -13819.696     -13990.564     -13990.564      330.55563      330.55563      47916.099      47916.099      583.28274      583.28274    
     18000  -13817.542     -13817.542     -13988.143     -13988.143      330.0391       330.0391       47940.167      47940.167      107.4604       107.4604     
Loop time of 585.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.618 hours/ns, 1.708 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.44     | 584.44     | 584.44     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14862    | 0.14862    | 0.14862    |   0.0 |  0.03
Output  | 0.00019095 | 0.00019095 | 0.00019095 |   0.0 |  0.00
Modify  | 0.73302    | 0.73302    | 0.73302    |   0.0 |  0.13
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530910 ave      530910 max      530910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530910
Ave neighs/atom = 132.7275
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 = 333.689616640897, Press = 0.0542723389050745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13817.542     -13817.542     -13988.143     -13988.143      330.0391       330.0391       47940.167      47940.167      107.4604       107.4604     
     19000  -13815.19      -13815.19      -13989.349     -13989.349      336.92185      336.92185      47945.55       47945.55       23.573552      23.573552    
Loop time of 580.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.149 ns/day, 161.285 hours/ns, 1.722 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 579.66     | 579.66     | 579.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14672    | 0.14672    | 0.14672    |   0.0 |  0.03
Output  | 0.00024303 | 0.00024303 | 0.00024303 |   0.0 |  0.00
Modify  | 0.72405    | 0.72405    | 0.72405    |   0.0 |  0.12
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530762 ave      530762 max      530762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530762
Ave neighs/atom = 132.6905
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 = 333.701947757786, Press = -0.51787931183914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13815.19      -13815.19      -13989.349     -13989.349      336.92185      336.92185      47945.55       47945.55       23.573552      23.573552    
     20000  -13821.043     -13821.043     -13990.842     -13990.842      328.48872      328.48872      47926.895      47926.895      248.9623       248.9623     
Loop time of 583.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.027 hours/ns, 1.714 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.32     | 582.32     | 582.32     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1472     | 0.1472     | 0.1472     |   0.0 |  0.03
Output  | 0.00019191 | 0.00019191 | 0.00019191 |   0.0 |  0.00
Modify  | 0.72828    | 0.72828    | 0.72828    |   0.0 |  0.12
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 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:       530758 ave      530758 max      530758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530758
Ave neighs/atom = 132.6895
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 = 333.51980828902, Press = 0.510220101062326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13821.043     -13821.043     -13990.842     -13990.842      328.48872      328.48872      47926.895      47926.895      248.9623       248.9623     
     21000  -13820.472     -13820.472     -13990.009     -13990.009      327.98137      327.98137      47949.982      47949.982     -233.21773     -233.21773    
Loop time of 580.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.149 ns/day, 161.368 hours/ns, 1.721 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 579.94     | 579.94     | 579.94     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14954    | 0.14954    | 0.14954    |   0.0 |  0.03
Output  | 0.00025671 | 0.00025671 | 0.00025671 |   0.0 |  0.00
Modify  | 0.73369    | 0.73369    | 0.73369    |   0.0 |  0.13
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 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:       530828 ave      530828 max      530828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530828
Ave neighs/atom = 132.707
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 = 333.457348936483, Press = 1.2928386844988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13820.472     -13820.472     -13990.009     -13990.009      327.98137      327.98137      47949.982      47949.982     -233.21773     -233.21773    
     22000  -13816.912     -13816.912     -13989.128     -13989.128      333.16299      333.16299      48003.842      48003.842     -1684.9518     -1684.9518    
Loop time of 585.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.569 hours/ns, 1.709 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.26     | 584.26     | 584.26     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14846    | 0.14846    | 0.14846    |   0.0 |  0.03
Output  | 0.00019521 | 0.00019521 | 0.00019521 |   0.0 |  0.00
Modify  | 0.73737    | 0.73737    | 0.73737    |   0.0 |  0.13
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530586 ave      530586 max      530586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530586
Ave neighs/atom = 132.6465
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 = 333.399335387551, Press = -1.29759412292431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13816.912     -13816.912     -13989.128     -13989.128      333.16299      333.16299      48003.842      48003.842     -1684.9518     -1684.9518    
     23000  -13825.201     -13825.201     -13991.577     -13991.577      321.86462      321.86462      47931.732      47931.732      13.626802      13.626802    
Loop time of 574.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 159.647 hours/ns, 1.740 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.76     | 573.76     | 573.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14726    | 0.14726    | 0.14726    |   0.0 |  0.03
Output  | 0.00019092 | 0.00019092 | 0.00019092 |   0.0 |  0.00
Modify  | 0.7174     | 0.7174     | 0.7174     |   0.0 |  0.12
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 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:       530628 ave      530628 max      530628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530628
Ave neighs/atom = 132.657
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 = 333.307126794875, Press = -3.50682436859477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13825.201     -13825.201     -13991.577     -13991.577      321.86462      321.86462      47931.732      47931.732      13.626802      13.626802    
     24000  -13818.178     -13818.178     -13992.388     -13992.388      337.02061      337.02061      47904.246      47904.246      913.87737      913.87737    
Loop time of 587.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.166 hours/ns, 1.702 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.4      | 586.4      | 586.4      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.03
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.74595    | 0.74595    | 0.74595    |   0.0 |  0.13
Other   |            | 0.103      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       531002 ave      531002 max      531002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531002
Ave neighs/atom = 132.7505
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 = 333.273362062963, Press = -0.766211141803762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13818.178     -13818.178     -13992.388     -13992.388      337.02061      337.02061      47904.246      47904.246      913.87737      913.87737    
     25000  -13816.49      -13816.49      -13989.68      -13989.68       335.04682      335.04682      47897.625      47897.625      1277.3335      1277.3335    
Loop time of 586.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.030 hours/ns, 1.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.92     | 585.92     | 585.92     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14914    | 0.14914    | 0.14914    |   0.0 |  0.03
Output  | 0.00019136 | 0.00019136 | 0.00019136 |   0.0 |  0.00
Modify  | 0.74135    | 0.74135    | 0.74135    |   0.0 |  0.13
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 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:       531178 ave      531178 max      531178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531178
Ave neighs/atom = 132.7945
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 = 333.319778116092, Press = 1.36142473667543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13816.49      -13816.49      -13989.68      -13989.68       335.04682      335.04682      47897.625      47897.625      1277.3335      1277.3335    
     26000  -13818.648     -13818.648     -13989.589     -13989.589      330.69865      330.69865      47943.616      47943.616     -5.2260602     -5.2260602    
Loop time of 587.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.147 ns/day, 163.132 hours/ns, 1.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.29     | 586.29     | 586.29     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15086    | 0.15086    | 0.15086    |   0.0 |  0.03
Output  | 0.00018916 | 0.00018916 | 0.00018916 |   0.0 |  0.00
Modify  | 0.73877    | 0.73877    | 0.73877    |   0.0 |  0.13
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5847 ave        5847 max        5847 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:       530984 ave      530984 max      530984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530984
Ave neighs/atom = 132.746
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 = 333.422053423491, Press = 2.47636483839215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13818.648     -13818.648     -13989.589     -13989.589      330.69865      330.69865      47943.616      47943.616     -5.2260602     -5.2260602    
     27000  -13812.911     -13812.911     -13987.979     -13987.979      338.6797       338.6797       48024.425      48024.425     -2115.9489     -2115.9489    
Loop time of 583.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.148 ns/day, 162.150 hours/ns, 1.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.76     | 582.76     | 582.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14852    | 0.14852    | 0.14852    |   0.0 |  0.03
Output  | 0.00019101 | 0.00019101 | 0.00019101 |   0.0 |  0.00
Modify  | 0.7346     | 0.7346     | 0.7346     |   0.0 |  0.13
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530952 ave      530952 max      530952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530952
Ave neighs/atom = 132.738
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 = 333.452866640127, Press = 0.551272448859837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13812.911     -13812.911     -13987.979     -13987.979      338.6797       338.6797       48024.425      48024.425     -2115.9489     -2115.9489    
     28000  -13820.627     -13820.627     -13990.537     -13990.537      328.70086      328.70086      47987.986      47987.986     -1395.1257     -1395.1257    
Loop time of 573.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.151 ns/day, 159.383 hours/ns, 1.743 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.82     | 572.82     | 572.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14565    | 0.14565    | 0.14565    |   0.0 |  0.03
Output  | 0.00019233 | 0.00019233 | 0.00019233 |   0.0 |  0.00
Modify  | 0.71464    | 0.71464    | 0.71464    |   0.0 |  0.12
Other   |            | 0.09949    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530056 ave      530056 max      530056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530056
Ave neighs/atom = 132.514
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 = 333.547538495275, Press = -2.54457746595045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13820.627     -13820.627     -13990.537     -13990.537      328.70086      328.70086      47987.986      47987.986     -1395.1257     -1395.1257    
     29000  -13816.941     -13816.941     -13990.966     -13990.966      336.66375      336.66375      47925.994      47925.994      387.27245      387.27245    
Loop time of 573.644 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.151 ns/day, 159.345 hours/ns, 1.743 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.68     | 572.68     | 572.68     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14704    | 0.14704    | 0.14704    |   0.0 |  0.03
Output  | 0.00024088 | 0.00024088 | 0.00024088 |   0.0 |  0.00
Modify  | 0.71516    | 0.71516    | 0.71516    |   0.0 |  0.12
Other   |            | 0.09869    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530552 ave      530552 max      530552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530552
Ave neighs/atom = 132.638
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 = 333.516246927291, Press = -1.17752361207762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13816.941     -13816.941     -13990.966     -13990.966      336.66375      336.66375      47925.994      47925.994      387.27245      387.27245    
     30000  -13818.159     -13818.159     -13991.732     -13991.732      335.78983      335.78983      47915.618      47915.618      607.1136       607.1136     
Loop time of 572.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.151 ns/day, 159.016 hours/ns, 1.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 571.51     | 571.51     | 571.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14625    | 0.14625    | 0.14625    |   0.0 |  0.03
Output  | 0.00024982 | 0.00024982 | 0.00024982 |   0.0 |  0.00
Modify  | 0.70586    | 0.70586    | 0.70586    |   0.0 |  0.12
Other   |            | 0.09875    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530756 ave      530756 max      530756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530756
Ave neighs/atom = 132.689
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 = 333.418988099329, Press = 0.300958214472403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13818.159     -13818.159     -13991.732     -13991.732      335.78983      335.78983      47915.618      47915.618      607.1136       607.1136     
     31000  -13822.715     -13822.715     -13992.397     -13992.397      328.26146      328.26146      47929.818      47929.818      71.834602      71.834602    
Loop time of 568.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.152 ns/day, 157.906 hours/ns, 1.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 567.51     | 567.51     | 567.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14627    | 0.14627    | 0.14627    |   0.0 |  0.03
Output  | 0.00019187 | 0.00019187 | 0.00019187 |   0.0 |  0.00
Modify  | 0.70734    | 0.70734    | 0.70734    |   0.0 |  0.12
Other   |            | 0.09823    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       531224 ave      531224 max      531224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531224
Ave neighs/atom = 132.806
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 = 333.363134308802, Press = 0.738010742296614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13822.715     -13822.715     -13992.397     -13992.397      328.26146      328.26146      47929.818      47929.818      71.834602      71.834602    
     32000  -13816.404     -13816.404     -13989.098     -13989.098      334.08912      334.08912      47991.739      47991.739     -1384.2928     -1384.2928    
Loop time of 577.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 160.340 hours/ns, 1.732 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.25     | 576.25     | 576.25     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14706    | 0.14706    | 0.14706    |   0.0 |  0.03
Output  | 0.00023766 | 0.00023766 | 0.00023766 |   0.0 |  0.00
Modify  | 0.7215     | 0.7215     | 0.7215     |   0.0 |  0.12
Other   |            | 0.09944    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 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:       531158 ave      531158 max      531158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531158
Ave neighs/atom = 132.7895
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 = 333.316903926697, Press = 0.996440107634924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13816.404     -13816.404     -13989.098     -13989.098      334.08912      334.08912      47991.739      47991.739     -1384.2928     -1384.2928    
     33000  -13819.051     -13819.051     -13990.472     -13990.472      331.62673      331.62673      48029.126      48029.126     -2602.2678     -2602.2678    
Loop time of 577.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 160.486 hours/ns, 1.731 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.78     | 576.78     | 576.78     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14841    | 0.14841    | 0.14841    |   0.0 |  0.03
Output  | 0.00019376 | 0.00019376 | 0.00019376 |   0.0 |  0.00
Modify  | 0.7244     | 0.7244     | 0.7244     |   0.0 |  0.13
Other   |            | 0.09965    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530334 ave      530334 max      530334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530334
Ave neighs/atom = 132.5835
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 = 333.311646623905, Press = -1.62986834568533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13819.051     -13819.051     -13990.472     -13990.472      331.62673      331.62673      48029.126      48029.126     -2602.2678     -2602.2678    
     34000  -13811.951     -13811.951     -13983.741     -13983.741      332.33913      332.33913      47953.966      47953.966      187.80295      187.80295    
Loop time of 577.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 160.283 hours/ns, 1.733 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.04     | 576.04     | 576.04     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.03
Output  | 0.00019008 | 0.00019008 | 0.00019008 |   0.0 |  0.00
Modify  | 0.72616    | 0.72616    | 0.72616    |   0.0 |  0.13
Other   |            | 0.09946    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530358 ave      530358 max      530358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530358
Ave neighs/atom = 132.5895
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 = 333.380089843763, Press = -1.50963963088941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13811.951     -13811.951     -13983.741     -13983.741      332.33913      332.33913      47953.966      47953.966      187.80295      187.80295    
     35000  -13817.107     -13817.107     -13989.815     -13989.815      334.11522      334.11522      47917.802      47917.802      677.74095      677.74095    
Loop time of 569.407 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.152 ns/day, 158.169 hours/ns, 1.756 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 568.45     | 568.45     | 568.45     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14635    | 0.14635    | 0.14635    |   0.0 |  0.03
Output  | 0.00018938 | 0.00018938 | 0.00018938 |   0.0 |  0.00
Modify  | 0.70789    | 0.70789    | 0.70789    |   0.0 |  0.12
Other   |            | 0.09817    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5846 ave        5846 max        5846 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:       530400 ave      530400 max      530400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530400
Ave neighs/atom = 132.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.405343339889, Press = -0.20217175533524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13817.107     -13817.107     -13989.815     -13989.815      334.11522      334.11522      47917.802      47917.802      677.74095      677.74095    
     36000  -13820.215     -13820.215     -13989.385     -13989.385      327.27125      327.27125      47919.344      47919.344      571.25284      571.25284    
Loop time of 572.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.151 ns/day, 159.115 hours/ns, 1.746 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 571.86     | 571.86     | 571.86     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14512    | 0.14512    | 0.14512    |   0.0 |  0.03
Output  | 0.00023964 | 0.00023964 | 0.00023964 |   0.0 |  0.00
Modify  | 0.70704    | 0.70704    | 0.70704    |   0.0 |  0.12
Other   |            | 0.09839    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530850 ave      530850 max      530850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530850
Ave neighs/atom = 132.7125
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 = 333.419065440827, Press = 0.510679770257947
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13820.215     -13820.215     -13989.385     -13989.385      327.27125      327.27125      47919.344      47919.344      571.25284      571.25284    
     37000  -13816.635     -13816.635     -13989.706     -13989.706      334.81678      334.81678      47975.722      47975.722     -979.80069     -979.80069    
Loop time of 574.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.151 ns/day, 159.455 hours/ns, 1.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.08     | 573.08     | 573.08     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14846    | 0.14846    | 0.14846    |   0.0 |  0.03
Output  | 0.00019272 | 0.00019272 | 0.00019272 |   0.0 |  0.00
Modify  | 0.71517    | 0.71517    | 0.71517    |   0.0 |  0.12
Other   |            | 0.0988     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 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:       530860 ave      530860 max      530860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530860
Ave neighs/atom = 132.715
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 = 333.393746530142, Press = 1.05619192256675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13816.635     -13816.635     -13989.706     -13989.706      334.81678      334.81678      47975.722      47975.722     -979.80069     -979.80069    
     38000  -13818.932     -13818.932     -13990.042     -13990.042      331.02378      331.02378      48021.928      48021.928     -2325.0054     -2325.0054    
Loop time of 578.045 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.149 ns/day, 160.568 hours/ns, 1.730 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.08     | 577.08     | 577.08     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14843    | 0.14843    | 0.14843    |   0.0 |  0.03
Output  | 0.0002371  | 0.0002371  | 0.0002371  |   0.0 |  0.00
Modify  | 0.71518    | 0.71518    | 0.71518    |   0.0 |  0.12
Other   |            | 0.0998     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530620 ave      530620 max      530620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530620
Ave neighs/atom = 132.655
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 = 333.409425916958, Press = -0.608555420430137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13818.932     -13818.932     -13990.042     -13990.042      331.02378      331.02378      48021.928      48021.928     -2325.0054     -2325.0054    
     39000  -13817.116     -13817.116     -13988.536     -13988.536      331.62354      331.62354      47959.044      47959.044     -389.36894     -389.36894    
Loop time of 578.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.149 ns/day, 160.570 hours/ns, 1.730 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.08     | 577.08     | 577.08     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.03
Output  | 0.00019245 | 0.00019245 | 0.00019245 |   0.0 |  0.00
Modify  | 0.72438    | 0.72438    | 0.72438    |   0.0 |  0.13
Other   |            | 0.09945    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530448 ave      530448 max      530448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530448
Ave neighs/atom = 132.612
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 = 333.390224594807, Press = -1.34419639836206
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13817.116     -13817.116     -13988.536     -13988.536      331.62354      331.62354      47959.044      47959.044     -389.36894     -389.36894    
     40000  -13816.04      -13816.04      -13989.09      -13989.09       334.77821      334.77821      47916.514      47916.514      809.54452      809.54452    
Loop time of 574.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 159.552 hours/ns, 1.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.42     | 573.42     | 573.42     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14683    | 0.14683    | 0.14683    |   0.0 |  0.03
Output  | 0.00019256 | 0.00019256 | 0.00019256 |   0.0 |  0.00
Modify  | 0.71781    | 0.71781    | 0.71781    |   0.0 |  0.12
Other   |            | 0.09899    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5847 ave        5847 max        5847 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:       530724 ave      530724 max      530724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530724
Ave neighs/atom = 132.681
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 = 333.386438454117, Press = -0.674278355500973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13816.04      -13816.04      -13989.09      -13989.09       334.77821      334.77821      47916.514      47916.514      809.54452      809.54452    
     41000  -13818.24      -13818.24      -13991.512     -13991.512      335.20662      335.20662      47912.478      47912.478      687.56319      687.56319    
Loop time of 577.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 160.323 hours/ns, 1.733 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.19     | 576.19     | 576.19     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14763    | 0.14763    | 0.14763    |   0.0 |  0.03
Output  | 0.00019147 | 0.00019147 | 0.00019147 |   0.0 |  0.00
Modify  | 0.72207    | 0.72207    | 0.72207    |   0.0 |  0.13
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       530966 ave      530966 max      530966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530966
Ave neighs/atom = 132.7415
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 = 333.33575293203, Press = 0.292184227853339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13818.24      -13818.24      -13991.512     -13991.512      335.20662      335.20662      47912.478      47912.478      687.56319      687.56319    
     42000  -13818.773     -13818.773     -13988.726     -13988.726      328.78599      328.78599      47934.12       47934.12       174.38998      174.38998    
Loop time of 574.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.150 ns/day, 159.523 hours/ns, 1.741 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.32     | 573.32     | 573.32     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.03
Output  | 0.00032473 | 0.00032473 | 0.00032473 |   0.0 |  0.00
Modify  | 0.718      | 0.718      | 0.718      |   0.0 |  0.13
Other   |            | 0.0996     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       531030 ave      531030 max      531030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531030
Ave neighs/atom = 132.7575
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
47939.5246887911

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0