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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5175609808 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_196726067688_001#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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8509.4205     -8509.4205     -8580          -8580           273.15         273.15         23483.518      23483.518      3210.2051      3210.2051    
      1000  -8435.9645     -8435.9645     -8504.112      -8504.112       263.73805      263.73805      23735.03       23735.03      -1633.172      -1633.172     
Loop time of 106.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.633 hours/ns, 9.374 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    | 106.14     | 106.14     | 106.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079448   | 0.079448   | 0.079448   |   0.0 |  0.07
Output  | 0.00024934 | 0.00024934 | 0.00024934 |   0.0 |  0.00
Modify  | 0.39888    | 0.39888    | 0.39888    |   0.0 |  0.37
Other   |            | 0.06094    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8435.9645     -8435.9645     -8504.112      -8504.112       263.73805      263.73805      23735.03       23735.03      -1633.172      -1633.172     
      2000  -8436.1934     -8436.1934     -8504.6273     -8504.6273      264.84645      264.84645      23705.147      23705.147      384.22125      384.22125    
Loop time of 112.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.313 hours/ns, 8.871 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    | 112.17     | 112.17     | 112.17     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081109   | 0.081109   | 0.081109   |   0.0 |  0.07
Output  | 0.00020694 | 0.00020694 | 0.00020694 |   0.0 |  0.00
Modify  | 0.41851    | 0.41851    | 0.41851    |   0.0 |  0.37
Other   |            | 0.06305    |            |       |  0.06

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

Total # of neighbors = 116746
Ave neighs/atom = 58.373
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8436.1934     -8436.1934     -8504.6273     -8504.6273      264.84645      264.84645      23705.147      23705.147      384.22125      384.22125    
      3000  -8437.3673     -8437.3673     -8507.9353     -8507.9353      273.10558      273.10558      23699.07       23699.07       479.45668      479.45668    
Loop time of 96.1292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.703 hours/ns, 10.403 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    | 95.669     | 95.669     | 95.669     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070215   | 0.070215   | 0.070215   |   0.0 |  0.07
Output  | 0.00021532 | 0.00021532 | 0.00021532 |   0.0 |  0.00
Modify  | 0.33358    | 0.33358    | 0.33358    |   0.0 |  0.35
Other   |            | 0.05655    |            |       |  0.06

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

Total # of neighbors = 116774
Ave neighs/atom = 58.387
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8437.3673     -8437.3673     -8507.9353     -8507.9353      273.10558      273.10558      23699.07       23699.07       479.45668      479.45668    
      4000  -8434.763      -8434.763      -8504.8188     -8504.8188      271.12332      271.12332      23713.377      23713.377     -145.50202     -145.50202    
Loop time of 95.9658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.657 hours/ns, 10.420 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    | 95.506     | 95.506     | 95.506     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07041    | 0.07041    | 0.07041    |   0.0 |  0.07
Output  | 0.00021232 | 0.00021232 | 0.00021232 |   0.0 |  0.00
Modify  | 0.33297    | 0.33297    | 0.33297    |   0.0 |  0.35
Other   |            | 0.05659    |            |       |  0.06

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

Total # of neighbors = 116664
Ave neighs/atom = 58.332
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8434.763      -8434.763      -8504.8188     -8504.8188      271.12332      271.12332      23713.377      23713.377     -145.50202     -145.50202    
      5000  -8437.9706     -8437.9706     -8507.9334     -8507.9334      270.76324      270.76324      23696.466      23696.466      512.39745      512.39745    
Loop time of 96.1681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.713 hours/ns, 10.398 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    | 95.705     | 95.705     | 95.705     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07057    | 0.07057    | 0.07057    |   0.0 |  0.07
Output  | 0.00017149 | 0.00017149 | 0.00017149 |   0.0 |  0.00
Modify  | 0.33567    | 0.33567    | 0.33567    |   0.0 |  0.35
Other   |            | 0.05695    |            |       |  0.06

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

Total # of neighbors = 116630
Ave neighs/atom = 58.315
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 = 270.903036686662, Press = -148.386614191195
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8437.9706     -8437.9706     -8507.9334     -8507.9334      270.76324      270.76324      23696.466      23696.466      512.39745      512.39745    
      6000  -8435.9883     -8435.9883     -8504.2454     -8504.2454      264.16182      264.16182      23704.561      23704.561      623.51992      623.51992    
Loop time of 95.9389 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.650 hours/ns, 10.423 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    | 95.458     | 95.458     | 95.458     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070849   | 0.070849   | 0.070849   |   0.0 |  0.07
Output  | 0.00017087 | 0.00017087 | 0.00017087 |   0.0 |  0.00
Modify  | 0.35327    | 0.35327    | 0.35327    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

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

Total # of neighbors = 116646
Ave neighs/atom = 58.323
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 = 271.713492968998, Press = -7.77804586094036
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8435.9883     -8435.9883     -8504.2454     -8504.2454      264.16182      264.16182      23704.561      23704.561      623.51992      623.51992    
      7000  -8436.2418     -8436.2418     -8507.9277     -8507.9277      277.43164      277.43164      23724.846      23724.846     -1279.2769     -1279.2769    
Loop time of 96.1958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.721 hours/ns, 10.395 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    | 95.714     | 95.714     | 95.714     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071439   | 0.071439   | 0.071439   |   0.0 |  0.07
Output  | 0.00020631 | 0.00020631 | 0.00020631 |   0.0 |  0.00
Modify  | 0.35449    | 0.35449    | 0.35449    |   0.0 |  0.37
Other   |            | 0.05618    |            |       |  0.06

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

Total # of neighbors = 116764
Ave neighs/atom = 58.382
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 = 272.514931972989, Press = -16.2650552773
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8436.2418     -8436.2418     -8507.9277     -8507.9277      277.43164      277.43164      23724.846      23724.846     -1279.2769     -1279.2769    
      8000  -8439.2681     -8439.2681     -8509.575      -8509.575       272.09486      272.09486      23678.145      23678.145      1661.9322      1661.9322    
Loop time of 96.0194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.672 hours/ns, 10.415 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    | 95.537     | 95.537     | 95.537     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070358   | 0.070358   | 0.070358   |   0.0 |  0.07
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.35483    | 0.35483    | 0.35483    |   0.0 |  0.37
Other   |            | 0.05683    |            |       |  0.06

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

Total # of neighbors = 116656
Ave neighs/atom = 58.328
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 = 272.21702860804, Press = -7.89563402999982
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8439.2681     -8439.2681     -8509.575      -8509.575       272.09486      272.09486      23678.145      23678.145      1661.9322      1661.9322    
      9000  -8435.0973     -8435.0973     -8506.8513     -8506.8513      277.6956       277.6956       23724.641      23724.641     -1232.9204     -1232.9204    
Loop time of 95.9802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.661 hours/ns, 10.419 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    | 95.499     | 95.499     | 95.499     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071192   | 0.071192   | 0.071192   |   0.0 |  0.07
Output  | 0.00020965 | 0.00020965 | 0.00020965 |   0.0 |  0.00
Modify  | 0.35337    | 0.35337    | 0.35337    |   0.0 |  0.37
Other   |            | 0.05628    |            |       |  0.06

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

Total # of neighbors = 116608
Ave neighs/atom = 58.304
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 = 272.291277541873, Press = 7.36406711100549
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8435.0973     -8435.0973     -8506.8513     -8506.8513      277.6956       277.6956       23724.641      23724.641     -1232.9204     -1232.9204    
     10000  -8433.4159     -8433.4159     -8502.8897     -8502.8897      268.87064      268.87064      23746.5        23746.5       -1996.5791     -1996.5791    
Loop time of 96.3495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.764 hours/ns, 10.379 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    | 95.867     | 95.867     | 95.867     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070857   | 0.070857   | 0.070857   |   0.0 |  0.07
Output  | 0.00016982 | 0.00016982 | 0.00016982 |   0.0 |  0.00
Modify  | 0.35496    | 0.35496    | 0.35496    |   0.0 |  0.37
Other   |            | 0.05668    |            |       |  0.06

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

Total # of neighbors = 116638
Ave neighs/atom = 58.319
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 = 272.505000043408, Press = -13.1321278095114
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8433.4159     -8433.4159     -8502.8897     -8502.8897      268.87064      268.87064      23746.5        23746.5       -1996.5791     -1996.5791    
     11000  -8436.6435     -8436.6435     -8506.2176     -8506.2176      269.25896      269.25896      23661.783      23661.783      3424.525       3424.525     
Loop time of 95.9347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.649 hours/ns, 10.424 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    | 95.453     | 95.453     | 95.453     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071105   | 0.071105   | 0.071105   |   0.0 |  0.07
Output  | 0.00017054 | 0.00017054 | 0.00017054 |   0.0 |  0.00
Modify  | 0.35357    | 0.35357    | 0.35357    |   0.0 |  0.37
Other   |            | 0.05692    |            |       |  0.06

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

Total # of neighbors = 116648
Ave neighs/atom = 58.324
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 = 273.011463909365, Press = -6.95989117743325
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8436.6435     -8436.6435     -8506.2176     -8506.2176      269.25896      269.25896      23661.783      23661.783      3424.525       3424.525     
     12000  -8432.8691     -8432.8691     -8505.2378     -8505.2378      280.07428      280.07428      23715.754      23715.754     -101.91257     -101.91257    
Loop time of 95.9934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.665 hours/ns, 10.417 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    | 95.514     | 95.514     | 95.514     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07075    | 0.07075    | 0.07075    |   0.0 |  0.07
Output  | 0.00017103 | 0.00017103 | 0.00017103 |   0.0 |  0.00
Modify  | 0.35129    | 0.35129    | 0.35129    |   0.0 |  0.37
Other   |            | 0.05701    |            |       |  0.06

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

Total # of neighbors = 116714
Ave neighs/atom = 58.357
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 = 273.165878481414, Press = 4.11848546096514
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8432.8691     -8432.8691     -8505.2378     -8505.2378      280.07428      280.07428      23715.754      23715.754     -101.91257     -101.91257    
     13000  -8437.1873     -8437.1873     -8507.532      -8507.532       272.24142      272.24142      23717.547      23717.547     -856.88428     -856.88428    
Loop time of 95.9943 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.665 hours/ns, 10.417 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    | 95.512     | 95.512     | 95.512     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070925   | 0.070925   | 0.070925   |   0.0 |  0.07
Output  | 0.00017019 | 0.00017019 | 0.00017019 |   0.0 |  0.00
Modify  | 0.3547     | 0.3547     | 0.3547     |   0.0 |  0.37
Other   |            | 0.0562     |            |       |  0.06

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

Total # of neighbors = 116622
Ave neighs/atom = 58.311
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 = 273.353441889646, Press = -5.33230667963618
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8437.1873     -8437.1873     -8507.532      -8507.532       272.24142      272.24142      23717.547      23717.547     -856.88428     -856.88428    
     14000  -8435.1318     -8435.1318     -8505.1277     -8505.1277      270.89146      270.89146      23699.971      23699.971      1010.5286      1010.5286    
Loop time of 96.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.703 hours/ns, 10.402 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    | 95.649     | 95.649     | 95.649     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070949   | 0.070949   | 0.070949   |   0.0 |  0.07
Output  | 0.00017094 | 0.00017094 | 0.00017094 |   0.0 |  0.00
Modify  | 0.35494    | 0.35494    | 0.35494    |   0.0 |  0.37
Other   |            | 0.05655    |            |       |  0.06

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

Total # of neighbors = 116574
Ave neighs/atom = 58.287
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 = 273.287917043919, Press = -2.29711319169548
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8435.1318     -8435.1318     -8505.1277     -8505.1277      270.89146      270.89146      23699.971      23699.971      1010.5286      1010.5286    
     15000  -8438.2536     -8438.2536     -8508.1397     -8508.1397      270.46665      270.46665      23705.438      23705.438     -146.62581     -146.62581    
Loop time of 106.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.550 hours/ns, 9.400 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    | 105.84     | 105.84     | 105.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076935   | 0.076935   | 0.076935   |   0.0 |  0.07
Output  | 0.0001736  | 0.0001736  | 0.0001736  |   0.0 |  0.00
Modify  | 0.40623    | 0.40623    | 0.40623    |   0.0 |  0.38
Other   |            | 0.06101    |            |       |  0.06

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

Total # of neighbors = 116610
Ave neighs/atom = 58.305
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 = 273.224998984038, Press = 1.16344083226445
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8438.2536     -8438.2536     -8508.1397     -8508.1397      270.46665      270.46665      23705.438      23705.438     -146.62581     -146.62581    
     16000  -8436.1128     -8436.1128     -8506.9749     -8506.9749      274.24366      274.24366      23736.709      23736.709     -2107.9171     -2107.9171    
Loop time of 113.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.647 hours/ns, 8.777 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.34     | 113.34     | 113.34     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082985   | 0.082985   | 0.082985   |   0.0 |  0.07
Output  | 0.00017423 | 0.00017423 | 0.00017423 |   0.0 |  0.00
Modify  | 0.4432     | 0.4432     | 0.4432     |   0.0 |  0.39
Other   |            | 0.06355    |            |       |  0.06

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

Total # of neighbors = 116632
Ave neighs/atom = 58.316
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 = 272.98184069018, Press = -6.43003493127639
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8436.1128     -8436.1128     -8506.9749     -8506.9749      274.24366      274.24366      23736.709      23736.709     -2107.9171     -2107.9171    
     17000  -8439.431      -8439.431      -8508.0304     -8508.0304      265.48666      265.48666      23660.576      23660.576      3155.362       3155.362     
Loop time of 103.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.826 hours/ns, 9.636 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    | 103.24     | 103.24     | 103.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075998   | 0.075998   | 0.075998   |   0.0 |  0.07
Output  | 0.00020291 | 0.00020291 | 0.00020291 |   0.0 |  0.00
Modify  | 0.3931     | 0.3931     | 0.3931     |   0.0 |  0.38
Other   |            | 0.05911    |            |       |  0.06

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

Total # of neighbors = 116610
Ave neighs/atom = 58.305
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 = 272.885352594814, Press = -3.3708265255424
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8439.431      -8439.431      -8508.0304     -8508.0304      265.48666      265.48666      23660.576      23660.576      3155.362       3155.362     
     18000  -8435.0814     -8435.0814     -8507.0948     -8507.0948      278.69924      278.69924      23714.942      23714.942     -456.50785     -456.50785    
Loop time of 96.1257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.702 hours/ns, 10.403 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    | 95.644     | 95.644     | 95.644     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070747   | 0.070747   | 0.070747   |   0.0 |  0.07
Output  | 0.00017149 | 0.00017149 | 0.00017149 |   0.0 |  0.00
Modify  | 0.35497    | 0.35497    | 0.35497    |   0.0 |  0.37
Other   |            | 0.05562    |            |       |  0.06

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

Total # of neighbors = 116634
Ave neighs/atom = 58.317
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 = 272.838770634945, Press = 3.5262608113362
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8435.0814     -8435.0814     -8507.0948     -8507.0948      278.69924      278.69924      23714.942      23714.942     -456.50785     -456.50785    
     19000  -8437.3922     -8437.3922     -8507.3891     -8507.3891      270.89508      270.89508      23728.744      23728.744     -1514.3817     -1514.3817    
Loop time of 107.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.832 hours/ns, 9.311 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    | 106.84     | 106.84     | 106.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079195   | 0.079195   | 0.079195   |   0.0 |  0.07
Output  | 0.0002168  | 0.0002168  | 0.0002168  |   0.0 |  0.00
Modify  | 0.4156     | 0.4156     | 0.4156     |   0.0 |  0.39
Other   |            | 0.06104    |            |       |  0.06

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

Total # of neighbors = 116610
Ave neighs/atom = 58.305
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 = 272.838740024584, Press = -2.84912551362656
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8437.3922     -8437.3922     -8507.3891     -8507.3891      270.89508      270.89508      23728.744      23728.744     -1514.3817     -1514.3817    
     20000  -8435.5179     -8435.5179     -8506.4091     -8506.4091      274.35612      274.35612      23697.514      23697.514      959.46527      959.46527    
Loop time of 113.503 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.529 hours/ns, 8.810 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.91     | 112.91     | 112.91     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082994   | 0.082994   | 0.082994   |   0.0 |  0.07
Output  | 0.00024405 | 0.00024405 | 0.00024405 |   0.0 |  0.00
Modify  | 0.44838    | 0.44838    | 0.44838    |   0.0 |  0.40
Other   |            | 0.06428    |            |       |  0.06

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

Total # of neighbors = 116608
Ave neighs/atom = 58.304
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 = 272.822230621483, Press = -1.95011638142384
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8435.5179     -8435.5179     -8506.4091     -8506.4091      274.35612      274.35612      23697.514      23697.514      959.46527      959.46527    
     21000  -8440.5958     -8440.5958     -8508.3552     -8508.3552      262.23581      262.23581      23696.353      23696.353      421.02083      421.02083    
Loop time of 110.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.798 hours/ns, 9.019 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.29     | 110.29     | 110.29     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08107    | 0.08107    | 0.08107    |   0.0 |  0.07
Output  | 0.00017223 | 0.00017223 | 0.00017223 |   0.0 |  0.00
Modify  | 0.43414    | 0.43414    | 0.43414    |   0.0 |  0.39
Other   |            | 0.06205    |            |       |  0.06

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

Total # of neighbors = 116650
Ave neighs/atom = 58.325
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 = 272.718379986263, Press = -0.765399500245693
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8440.5958     -8440.5958     -8508.3552     -8508.3552      262.23581      262.23581      23696.353      23696.353      421.02083      421.02083    
     22000  -8436.9461     -8436.9461     -8507.389      -8507.389       272.6211       272.6211       23705.149      23705.149      181.58452      181.58452    
Loop time of 96.7009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.861 hours/ns, 10.341 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    | 96.216     | 96.216     | 96.216     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070896   | 0.070896   | 0.070896   |   0.0 |  0.07
Output  | 0.00017303 | 0.00017303 | 0.00017303 |   0.0 |  0.00
Modify  | 0.35687    | 0.35687    | 0.35687    |   0.0 |  0.37
Other   |            | 0.05648    |            |       |  0.06

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

Total # of neighbors = 116600
Ave neighs/atom = 58.3
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 = 272.733655794204, Press = -1.32530023189721
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8436.9461     -8436.9461     -8507.389      -8507.389       272.6211       272.6211       23705.149      23705.149      181.58452      181.58452    
     23000  -8433.5635     -8433.5635     -8504.289      -8504.289       273.71506      273.71506      23713.641      23713.641      79.857149      79.857149    
Loop time of 96.7428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.873 hours/ns, 10.337 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.259     | 96.259     | 96.259     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072249   | 0.072249   | 0.072249   |   0.0 |  0.07
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.35646    | 0.35646    | 0.35646    |   0.0 |  0.37
Other   |            | 0.05481    |            |       |  0.06

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

Total # of neighbors = 116678
Ave neighs/atom = 58.339
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 = 272.799924943546, Press = -0.908569549116164
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8433.5635     -8433.5635     -8504.289      -8504.289       273.71506      273.71506      23713.641      23713.641      79.857149      79.857149    
     24000  -8438.4361     -8438.4361     -8507.6611     -8507.6611      267.90811      267.90811      23695.957      23695.957      711.52712      711.52712    
Loop time of 110.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.807 hours/ns, 9.017 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.33     | 110.33     | 110.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080984   | 0.080984   | 0.080984   |   0.0 |  0.07
Output  | 0.00021813 | 0.00021813 | 0.00021813 |   0.0 |  0.00
Modify  | 0.43385    | 0.43385    | 0.43385    |   0.0 |  0.39
Other   |            | 0.06315    |            |       |  0.06

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

Total # of neighbors = 116712
Ave neighs/atom = 58.356
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 = 272.919091005439, Press = -0.776799878418957
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8438.4361     -8438.4361     -8507.6611     -8507.6611      267.90811      267.90811      23695.957      23695.957      711.52712      711.52712    
     25000  -8433.0483     -8433.0483     -8505.9321     -8505.9321      282.06785      282.06785      23721.838      23721.838     -815.99068     -815.99068    
Loop time of 113.53 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.536 hours/ns, 8.808 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.94     | 112.94     | 112.94     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082983   | 0.082983   | 0.082983   |   0.0 |  0.07
Output  | 0.00021143 | 0.00021143 | 0.00021143 |   0.0 |  0.00
Modify  | 0.43983    | 0.43983    | 0.43983    |   0.0 |  0.39
Other   |            | 0.06341    |            |       |  0.06

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

Total # of neighbors = 116638
Ave neighs/atom = 58.319
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 = 272.996124475079, Press = -0.30656806554093
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8433.0483     -8433.0483     -8505.9321     -8505.9321      282.06785      282.06785      23721.838      23721.838     -815.99068     -815.99068    
     26000  -8438.018      -8438.018      -8509.6741     -8509.6741      277.31622      277.31622      23723.796      23723.796     -1519.4378     -1519.4378    
Loop time of 112.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.769 ns/day, 31.209 hours/ns, 8.900 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    | 111.77     | 111.77     | 111.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082359   | 0.082359   | 0.082359   |   0.0 |  0.07
Output  | 0.00023301 | 0.00023301 | 0.00023301 |   0.0 |  0.00
Modify  | 0.43898    | 0.43898    | 0.43898    |   0.0 |  0.39
Other   |            | 0.06254    |            |       |  0.06

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

Total # of neighbors = 116656
Ave neighs/atom = 58.328
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 = 273.056962737841, Press = -2.94077764050534
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8438.018      -8438.018      -8509.6741     -8509.6741      277.31622      277.31622      23723.796      23723.796     -1519.4378     -1519.4378    
     27000  -8434.8222     -8434.8222     -8506.7326     -8506.7326      278.30084      278.30084      23671.527      23671.527      2673.1436      2673.1436    
Loop time of 113.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.587 hours/ns, 8.794 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    | 113.12     | 113.12     | 113.12     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082344   | 0.082344   | 0.082344   |   0.0 |  0.07
Output  | 0.00017145 | 0.00017145 | 0.00017145 |   0.0 |  0.00
Modify  | 0.44851    | 0.44851    | 0.44851    |   0.0 |  0.39
Other   |            | 0.06336    |            |       |  0.06

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

Total # of neighbors = 116574
Ave neighs/atom = 58.287
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 = 273.093852874406, Press = -1.73363533018195
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8434.8222     -8434.8222     -8506.7326     -8506.7326      278.30084      278.30084      23671.527      23671.527      2673.1436      2673.1436    
     28000  -8437.4428     -8437.4428     -8509.4387     -8509.4387      278.63166      278.63166      23713.554      23713.554     -798.73944     -798.73944    
Loop time of 113.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.570 hours/ns, 8.799 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    | 113.06     | 113.06     | 113.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082078   | 0.082078   | 0.082078   |   0.0 |  0.07
Output  | 0.00021825 | 0.00021825 | 0.00021825 |   0.0 |  0.00
Modify  | 0.44368    | 0.44368    | 0.44368    |   0.0 |  0.39
Other   |            | 0.06367    |            |       |  0.06

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

Total # of neighbors = 116652
Ave neighs/atom = 58.326
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 = 273.104769277196, Press = 2.04817544155107
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8437.4428     -8437.4428     -8509.4387     -8509.4387      278.63166      278.63166      23713.554      23713.554     -798.73944     -798.73944    
     29000  -8434.6629     -8434.6629     -8504.2832     -8504.2832      269.43812      269.43812      23717.713      23717.713     -254.38083     -254.38083    
Loop time of 113.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.582 hours/ns, 8.795 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.1      | 113.1      | 113.1      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083143   | 0.083143   | 0.083143   |   0.0 |  0.07
Output  | 0.00017122 | 0.00017122 | 0.00017122 |   0.0 |  0.00
Modify  | 0.45054    | 0.45054    | 0.45054    |   0.0 |  0.40
Other   |            | 0.06455    |            |       |  0.06

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

Total # of neighbors = 116600
Ave neighs/atom = 58.3
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 = 273.007219749301, Press = -2.03623450963554
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8434.6629     -8434.6629     -8504.2832     -8504.2832      269.43812      269.43812      23717.713      23717.713     -254.38083     -254.38083    
     30000  -8436.4621     -8436.4621     -8507.0915     -8507.0915      273.34312      273.34312      23703.836      23703.836      297.33166      297.33166    
Loop time of 113.809 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.614 hours/ns, 8.787 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.21     | 113.21     | 113.21     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083585   | 0.083585   | 0.083585   |   0.0 |  0.07
Output  | 0.00017296 | 0.00017296 | 0.00017296 |   0.0 |  0.00
Modify  | 0.45079    | 0.45079    | 0.45079    |   0.0 |  0.40
Other   |            | 0.06436    |            |       |  0.06

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

Total # of neighbors = 116680
Ave neighs/atom = 58.34
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 = 273.022404720759, Press = -1.38181891217179
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8436.4621     -8436.4621     -8507.0915     -8507.0915      273.34312      273.34312      23703.836      23703.836      297.33166      297.33166    
     31000  -8433.7275     -8433.7275     -8505.66       -8505.66        278.38617      278.38617      23700.819      23700.819      749.8824       749.8824     
Loop time of 114.001 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.667 hours/ns, 8.772 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.41     | 113.41     | 113.41     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083446   | 0.083446   | 0.083446   |   0.0 |  0.07
Output  | 0.00016995 | 0.00016995 | 0.00016995 |   0.0 |  0.00
Modify  | 0.44636    | 0.44636    | 0.44636    |   0.0 |  0.39
Other   |            | 0.06408    |            |       |  0.06

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

Total # of neighbors = 116654
Ave neighs/atom = 58.327
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 = 273.143586865034, Press = -0.524446677835267
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8433.7275     -8433.7275     -8505.66       -8505.66        278.38617      278.38617      23700.819      23700.819      749.8824       749.8824     
     32000  -8435.6164     -8435.6164     -8506.4274     -8506.4274      274.0461       274.0461       23725.635      23725.635     -1190.1474     -1190.1474    
Loop time of 103.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.618 hours/ns, 9.706 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.5      | 102.5      | 102.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076469   | 0.076469   | 0.076469   |   0.0 |  0.07
Output  | 0.00020881 | 0.00020881 | 0.00020881 |   0.0 |  0.00
Modify  | 0.39289    | 0.39289    | 0.39289    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

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

Total # of neighbors = 116686
Ave neighs/atom = 58.343
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 = 273.153086122411, Press = -0.321083650525037
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8435.6164     -8435.6164     -8506.4274     -8506.4274      274.0461       274.0461       23725.635      23725.635     -1190.1474     -1190.1474    
     33000  -8434.7708     -8434.7708     -8506.7854     -8506.7854      278.7039       278.7039       23722.285      23722.285     -979.25363     -979.25363    
Loop time of 106.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.550 hours/ns, 9.400 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    | 105.83     | 105.83     | 105.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077976   | 0.077976   | 0.077976   |   0.0 |  0.07
Output  | 0.00023397 | 0.00023397 | 0.00023397 |   0.0 |  0.00
Modify  | 0.40682    | 0.40682    | 0.40682    |   0.0 |  0.38
Other   |            | 0.05996    |            |       |  0.06

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

Total # of neighbors = 116638
Ave neighs/atom = 58.319
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 = 273.186140356949, Press = -3.43893528069039
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8434.7708     -8434.7708     -8506.7854     -8506.7854      278.7039       278.7039       23722.285      23722.285     -979.25363     -979.25363    
     34000  -8438.315      -8438.315      -8507.2709     -8507.2709      266.86664      266.86664      23665.867      23665.867      2837.1034      2837.1034    
Loop time of 113.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.446 hours/ns, 8.833 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    | 112.62     | 112.62     | 112.62     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081796   | 0.081796   | 0.081796   |   0.0 |  0.07
Output  | 0.00020172 | 0.00020172 | 0.00020172 |   0.0 |  0.00
Modify  | 0.44327    | 0.44327    | 0.44327    |   0.0 |  0.39
Other   |            | 0.06301    |            |       |  0.06

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

Total # of neighbors = 116630
Ave neighs/atom = 58.315
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
23708.1224122186

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0