# 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_KimShinLee_2009_FeMn__MO_058735400462_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

# initial volume
variable      v equal vol        # assign formula
variable      V0 equal ${v}    # evaluate initial value
variable      V0 equal 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_058735400462_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 94.0575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.919 ns/day, 26.127 hours/ns, 10.632 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    | 93.591     | 93.591     | 93.591     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072907   | 0.072907   | 0.072907   |   0.0 |  0.08
Output  | 0.00024524 | 0.00024524 | 0.00024524 |   0.0 |  0.00
Modify  | 0.33726    | 0.33726    | 0.33726    |   0.0 |  0.36
Other   |            | 0.05564    |            |       |  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.22124      384.22124    
Loop time of 96.0687 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.686 hours/ns, 10.409 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.607     | 95.607     | 95.607     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0719     | 0.0719     | 0.0719     |   0.0 |  0.07
Output  | 0.00024383 | 0.00024383 | 0.00024383 |   0.0 |  0.00
Modify  | 0.33434    | 0.33434    | 0.33434    |   0.0 |  0.35
Other   |            | 0.05515    |            |       |  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.22124      384.22124    
      3000  -8437.3673     -8437.3673     -8507.9353     -8507.9353      273.10558      273.10558      23699.07       23699.07       479.45669      479.45669    
Loop time of 96.1957 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.734     | 95.734     | 95.734     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072543   | 0.072543   | 0.072543   |   0.0 |  0.08
Output  | 0.00020878 | 0.00020878 | 0.00020878 |   0.0 |  0.00
Modify  | 0.33375    | 0.33375    | 0.33375    |   0.0 |  0.35
Other   |            | 0.05566    |            |       |  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.45669      479.45669    
      4000  -8434.763      -8434.763      -8504.8188     -8504.8188      271.12332      271.12332      23713.377      23713.377     -145.50203     -145.50203    
Loop time of 96.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.668 hours/ns, 10.416 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.547     | 95.547     | 95.547     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072306   | 0.072306   | 0.072306   |   0.0 |  0.08
Output  | 0.0002103  | 0.0002103  | 0.0002103  |   0.0 |  0.00
Modify  | 0.33073    | 0.33073    | 0.33073    |   0.0 |  0.34
Other   |            | 0.05522    |            |       |  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.50203     -145.50203    
      5000  -8437.9706     -8437.9706     -8507.9334     -8507.9334      270.76324      270.76324      23696.466      23696.466      512.39743      512.39743    
Loop time of 96.1898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.719 hours/ns, 10.396 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.725     | 95.725     | 95.725     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072887   | 0.072887   | 0.072887   |   0.0 |  0.08
Output  | 0.00017039 | 0.00017039 | 0.00017039 |   0.0 |  0.00
Modify  | 0.33597    | 0.33597    | 0.33597    |   0.0 |  0.35
Other   |            | 0.05576    |            |       |  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.903036639528, Press = -148.386613491048
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.39743      512.39743    
      6000  -8435.9883     -8435.9883     -8504.2454     -8504.2454      264.16182      264.16182      23704.561      23704.561      623.51995      623.51995    
Loop time of 95.9758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.660 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.494     | 95.494     | 95.494     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073333   | 0.073333   | 0.073333   |   0.0 |  0.08
Output  | 0.00016894 | 0.00016894 | 0.00016894 |   0.0 |  0.00
Modify  | 0.35255    | 0.35255    | 0.35255    |   0.0 |  0.37
Other   |            | 0.05543    |            |       |  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.713492975076, Press = -7.77804617762737
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.51995      623.51995    
      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.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.716 hours/ns, 10.397 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.696     | 95.696     | 95.696     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07329    | 0.07329    | 0.07329    |   0.0 |  0.08
Output  | 0.00016727 | 0.00016727 | 0.00016727 |   0.0 |  0.00
Modify  | 0.35417    | 0.35417    | 0.35417    |   0.0 |  0.37
Other   |            | 0.0555     |            |       |  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.514931951178, Press = -16.2650539872518
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.9321      1661.9321    
Loop time of 95.9951 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.515     | 95.515     | 95.515     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072723   | 0.072723   | 0.072723   |   0.0 |  0.08
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.35182    | 0.35182    | 0.35182    |   0.0 |  0.37
Other   |            | 0.05522    |            |       |  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.217028636993, Press = -7.89563512200885
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.9321      1661.9321    
      9000  -8435.0973     -8435.0973     -8506.8513     -8506.8513      277.6956       277.6956       23724.641      23724.641     -1232.9202     -1232.9202    
Loop time of 95.9403 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.459     | 95.459     | 95.459     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072969   | 0.072969   | 0.072969   |   0.0 |  0.08
Output  | 0.00016975 | 0.00016975 | 0.00016975 |   0.0 |  0.00
Modify  | 0.35325    | 0.35325    | 0.35325    |   0.0 |  0.37
Other   |            | 0.05529    |            |       |  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.291277385286, Press = 7.36406616094513
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.9202     -1232.9202    
     10000  -8433.4159     -8433.4159     -8502.8897     -8502.8897      268.87064      268.87064      23746.5        23746.5       -1996.5845     -1996.5845    
Loop time of 96.3241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.757 hours/ns, 10.382 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.842     | 95.842     | 95.842     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073031   | 0.073031   | 0.073031   |   0.0 |  0.08
Output  | 0.00016882 | 0.00016882 | 0.00016882 |   0.0 |  0.00
Modify  | 0.35398    | 0.35398    | 0.35398    |   0.0 |  0.37
Other   |            | 0.05515    |            |       |  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.504998265895, Press = -13.1321345581663
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.5845     -1996.5845    
     11000  -8436.6435     -8436.6435     -8506.2176     -8506.2176      269.25898      269.25898      23661.784      23661.784      3424.5152      3424.5152    
Loop time of 95.9261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.646 hours/ns, 10.425 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.442     | 95.442     | 95.442     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072675   | 0.072675   | 0.072675   |   0.0 |  0.08
Output  | 0.00016908 | 0.00016908 | 0.00016908 |   0.0 |  0.00
Modify  | 0.35555    | 0.35555    | 0.35555    |   0.0 |  0.37
Other   |            | 0.05589    |            |       |  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.011463816393, Press = -6.95989627518031
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.25898      269.25898      23661.784      23661.784      3424.5152      3424.5152    
     12000  -8432.8693     -8432.8693     -8505.2379     -8505.2379      280.07395      280.07395      23715.753      23715.753     -101.88638     -101.88638    
Loop time of 96.1654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.713 hours/ns, 10.399 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.681     | 95.681     | 95.681     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07322    | 0.07322    | 0.07322    |   0.0 |  0.08
Output  | 0.00017034 | 0.00017034 | 0.00017034 |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   0.0 |  0.37
Other   |            | 0.05561    |            |       |  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.165871407718, Press = 4.11849724372039
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.8693     -8432.8693     -8505.2379     -8505.2379      280.07395      280.07395      23715.753      23715.753     -101.88638     -101.88638    
     13000  -8437.1875     -8437.1875     -8507.5322     -8507.5322      272.24095      272.24095      23717.547      23717.547     -856.88833     -856.88833    
Loop time of 96.2313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.731 hours/ns, 10.392 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.747     | 95.747     | 95.747     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072848   | 0.072848   | 0.072848   |   0.0 |  0.08
Output  | 0.0001689  | 0.0001689  | 0.0001689  |   0.0 |  0.00
Modify  | 0.35579    | 0.35579    | 0.35579    |   0.0 |  0.37
Other   |            | 0.05514    |            |       |  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.353425207433, Press = -5.33234392585782
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.1875     -8437.1875     -8507.5322     -8507.5322      272.24095      272.24095      23717.547      23717.547     -856.88833     -856.88833    
     14000  -8435.1315     -8435.1315     -8505.1276     -8505.1276      270.89187      270.89187      23699.971      23699.971      1010.5086      1010.5086    
Loop time of 96.3723 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.770 hours/ns, 10.376 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.887     | 95.887     | 95.887     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073382   | 0.073382   | 0.073382   |   0.0 |  0.08
Output  | 0.00016817 | 0.00016817 | 0.00016817 |   0.0 |  0.00
Modify  | 0.35579    | 0.35579    | 0.35579    |   0.0 |  0.37
Other   |            | 0.05571    |            |       |  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.287896522969, Press = -2.29708973928166
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.1315     -8435.1315     -8505.1276     -8505.1276      270.89187      270.89187      23699.971      23699.971      1010.5086      1010.5086    
     15000  -8438.2557     -8438.2557     -8508.1411     -8508.1411      270.4635       270.4635       23705.434      23705.434     -146.56683     -146.56683    
Loop time of 96.3433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.762 hours/ns, 10.380 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.859     | 95.859     | 95.859     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073135   | 0.073135   | 0.073135   |   0.0 |  0.08
Output  | 0.0001695  | 0.0001695  | 0.0001695  |   0.0 |  0.00
Modify  | 0.35537    | 0.35537    | 0.35537    |   0.0 |  0.37
Other   |            | 0.05551    |            |       |  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.225104446315, Press = 1.16268380369267
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.2557     -8438.2557     -8508.1411     -8508.1411      270.4635       270.4635       23705.434      23705.434     -146.56683     -146.56683    
     16000  -8436.1111     -8436.1111     -8506.9742     -8506.9742      274.24769      274.24769      23736.689      23736.689     -2106.3576     -2106.3576    
Loop time of 96.4093 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.372 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.925     | 95.925     | 95.925     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073635   | 0.073635   | 0.073635   |   0.0 |  0.08
Output  | 0.00020787 | 0.00020787 | 0.00020787 |   0.0 |  0.00
Modify  | 0.35508    | 0.35508    | 0.35508    |   0.0 |  0.37
Other   |            | 0.05532    |            |       |  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.98218362361, Press = -6.4272529359209
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.1111     -8436.1111     -8506.9742     -8506.9742      274.24769      274.24769      23736.689      23736.689     -2106.3576     -2106.3576    
     17000  -8439.4415     -8439.4415     -8508.036      -8508.036       265.46787      265.46787      23660.57       23660.57       3154.5616      3154.5616    
Loop time of 96.3067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.752 hours/ns, 10.383 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.823     | 95.823     | 95.823     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073189   | 0.073189   | 0.073189   |   0.0 |  0.08
Output  | 0.00016787 | 0.00016787 | 0.00016787 |   0.0 |  0.00
Modify  | 0.3548     | 0.3548     | 0.3548     |   0.0 |  0.37
Other   |            | 0.05578    |            |       |  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.885464058712, Press = -3.36866226576651
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.4415     -8439.4415     -8508.036      -8508.036       265.46787      265.46787      23660.57       23660.57       3154.5616      3154.5616    
     18000  -8435.1307     -8435.1307     -8507.1204     -8507.1204      278.60747      278.60747      23714.894      23714.894     -458.7911      -458.7911     
Loop time of 96.3386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.761 hours/ns, 10.380 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.855     | 95.855     | 95.855     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072836   | 0.072836   | 0.072836   |   0.0 |  0.08
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.35513    | 0.35513    | 0.35513    |   0.0 |  0.37
Other   |            | 0.05573    |            |       |  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.841163153664, Press = 3.5096364145665
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.1307     -8435.1307     -8507.1204     -8507.1204      278.60747      278.60747      23714.894      23714.894     -458.7911      -458.7911     
     19000  -8437.255      -8437.255      -8507.3118     -8507.3118      271.12696      271.12696      23729.01       23729.01      -1516.758      -1516.758     
Loop time of 96.4562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.793 hours/ns, 10.367 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.971     | 95.971     | 95.971     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073742   | 0.073742   | 0.073742   |   0.0 |  0.08
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.3553     | 0.3553     | 0.3553     |   0.0 |  0.37
Other   |            | 0.05561    |            |       |  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.843101666268, Press = -2.8575473725628
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.255      -8437.255      -8507.3118     -8507.3118      271.12696      271.12696      23729.01       23729.01      -1516.758      -1516.758     
     20000  -8435.8288     -8435.8288     -8506.5737     -8506.5737      273.7902       273.7902       23697.336      23697.336      935.89915      935.89915    
Loop time of 96.5126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.809 hours/ns, 10.361 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.028     | 96.028     | 96.028     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07305    | 0.07305    | 0.07305    |   0.0 |  0.08
Output  | 0.00016851 | 0.00016851 | 0.00016851 |   0.0 |  0.00
Modify  | 0.35613    | 0.35613    | 0.35613    |   0.0 |  0.37
Other   |            | 0.05561    |            |       |  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.81802521273, Press = -1.95283590289033
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.8288     -8435.8288     -8506.5737     -8506.5737      273.7902       273.7902       23697.336      23697.336      935.89915      935.89915    
     21000  -8440.169      -8440.169      -8508.0795     -8508.0795      262.82043      262.82043      23697.258      23697.258      413.52615      413.52615    
Loop time of 96.4189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.783 hours/ns, 10.371 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.934     | 95.934     | 95.934     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072632   | 0.072632   | 0.072632   |   0.0 |  0.08
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.35616    | 0.35616    | 0.35616    |   0.0 |  0.37
Other   |            | 0.05566    |            |       |  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:       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 = 272.749294943329, Press = -0.607094298703723
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.169      -8440.169      -8508.0795     -8508.0795      262.82043      262.82043      23697.258      23697.258      413.52615      413.52615    
     22000  -8435.6755     -8435.6755     -8506.6933     -8506.6933      274.84594      274.84594      23713.229      23713.229     -242.85043     -242.85043    
Loop time of 96.4066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.373 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.922     | 95.922     | 95.922     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072412   | 0.072412   | 0.072412   |   0.0 |  0.08
Output  | 0.0002052  | 0.0002052  | 0.0002052  |   0.0 |  0.00
Modify  | 0.35615    | 0.35615    | 0.35615    |   0.0 |  0.37
Other   |            | 0.05578    |            |       |  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.723560577127, Press = -1.58359877645801
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  -8435.6755     -8435.6755     -8506.6933     -8506.6933      274.84594      274.84594      23713.229      23713.229     -242.85043     -242.85043    
     23000  -8438.8842     -8438.8842     -8507.148      -8507.148       264.18798      264.18798      23698.251      23698.251      551.46703      551.46703    
Loop time of 96.5167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.810 hours/ns, 10.361 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.031     | 96.031     | 96.031     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07302    | 0.07302    | 0.07302    |   0.0 |  0.08
Output  | 0.00021747 | 0.00021747 | 0.00021747 |   0.0 |  0.00
Modify  | 0.35656    | 0.35656    | 0.35656    |   0.0 |  0.37
Other   |            | 0.05594    |            |       |  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:       116676 ave      116676 max      116676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116676
Ave neighs/atom = 58.338
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.585348857721, Press = -1.55859081210515
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  -8438.8842     -8438.8842     -8507.148      -8507.148       264.18798      264.18798      23698.251      23698.251      551.46703      551.46703    
     24000  -8437.1151     -8437.1151     -8507.0125     -8507.0125      270.51037      270.51037      23684.993      23684.993      1637.2421      1637.2421    
Loop time of 96.3106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.753 hours/ns, 10.383 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.825     | 95.825     | 95.825     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073456   | 0.073456   | 0.073456   |   0.0 |  0.08
Output  | 0.00016874 | 0.00016874 | 0.00016874 |   0.0 |  0.00
Modify  | 0.35612    | 0.35612    | 0.35612    |   0.0 |  0.37
Other   |            | 0.05548    |            |       |  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:       116688 ave      116688 max      116688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116688
Ave neighs/atom = 58.344
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.600844441869, Press = 1.23205218868873
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  -8437.1151     -8437.1151     -8507.0125     -8507.0125      270.51037      270.51037      23684.993      23684.993      1637.2421      1637.2421    
     25000  -8438.9702     -8438.9702     -8508.744      -8508.744       270.03189      270.03189      23746.969      23746.969     -3249.1608     -3249.1608    
Loop time of 96.4919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.803 hours/ns, 10.364 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.006     | 96.006     | 96.006     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072769   | 0.072769   | 0.072769   |   0.0 |  0.08
Output  | 0.00017044 | 0.00017044 | 0.00017044 |   0.0 |  0.00
Modify  | 0.35788    | 0.35788    | 0.35788    |   0.0 |  0.37
Other   |            | 0.0552     |            |       |  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:       116666 ave      116666 max      116666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116666
Ave neighs/atom = 58.333
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.48501558281, Press = -0.283152823939808
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  -8438.9702     -8438.9702     -8508.744      -8508.744       270.03189      270.03189      23746.969      23746.969     -3249.1608     -3249.1608    
     26000  -8434.3417     -8434.3417     -8508.004      -8508.004       285.08089      285.08089      23711.204      23711.204     -229.74643     -229.74643    
Loop time of 95.9237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.645 hours/ns, 10.425 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.436     | 95.436     | 95.436     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073151   | 0.073151   | 0.073151   |   0.0 |  0.08
Output  | 0.00017014 | 0.00017014 | 0.00017014 |   0.0 |  0.00
Modify  | 0.35838    | 0.35838    | 0.35838    |   0.0 |  0.37
Other   |            | 0.05565    |            |       |  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:       116582 ave      116582 max      116582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116582
Ave neighs/atom = 58.291
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.461883539474, Press = -4.31610485042512
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  -8434.3417     -8434.3417     -8508.004      -8508.004       285.08089      285.08089      23711.204      23711.204     -229.74643     -229.74643    
     27000  -8436.6134     -8436.6134     -8507.5688     -8507.5688      274.60492      274.60492      23690.484      23690.484      1132.688       1132.688     
Loop time of 96.4189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.783 hours/ns, 10.371 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.934     | 95.934     | 95.934     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072994   | 0.072994   | 0.072994   |   0.0 |  0.08
Output  | 0.0001676  | 0.0001676  | 0.0001676  |   0.0 |  0.00
Modify  | 0.35581    | 0.35581    | 0.35581    |   0.0 |  0.37
Other   |            | 0.05559    |            |       |  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:       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.456070924172, Press = -0.231727612604693
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  -8436.6134     -8436.6134     -8507.5688     -8507.5688      274.60492      274.60492      23690.484      23690.484      1132.688       1132.688     
     28000  -8434.8559     -8434.8559     -8508.2732     -8508.2732      284.13265      284.13265      23715.707      23715.707     -693.88788     -693.88788    
Loop time of 96.3398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.761 hours/ns, 10.380 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.855     | 95.855     | 95.855     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073545   | 0.073545   | 0.073545   |   0.0 |  0.08
Output  | 0.00016858 | 0.00016858 | 0.00016858 |   0.0 |  0.00
Modify  | 0.35522    | 0.35522    | 0.35522    |   0.0 |  0.37
Other   |            | 0.05555    |            |       |  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:       116598 ave      116598 max      116598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116598
Ave neighs/atom = 58.299
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.538158881656, Press = -0.529168171407699
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  -8434.8559     -8434.8559     -8508.2732     -8508.2732      284.13265      284.13265      23715.707      23715.707     -693.88788     -693.88788    
     29000  -8436.2815     -8436.2815     -8505.0087     -8505.0087      265.98128      265.98128      23705.016      23705.016      480.04628      480.04628    
Loop time of 96.2049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.724 hours/ns, 10.394 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.72      | 95.72      | 95.72      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073091   | 0.073091   | 0.073091   |   0.0 |  0.08
Output  | 0.00016859 | 0.00016859 | 0.00016859 |   0.0 |  0.00
Modify  | 0.35568    | 0.35568    | 0.35568    |   0.0 |  0.37
Other   |            | 0.05619    |            |       |  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:       116618 ave      116618 max      116618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116618
Ave neighs/atom = 58.309
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.521853150239, Press = -1.7507439119854
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  -8436.2815     -8436.2815     -8505.0087     -8505.0087      265.98128      265.98128      23705.016      23705.016      480.04628      480.04628    
     30000  -8437.4676     -8437.4676     -8507.5539     -8507.5539      271.24119      271.24119      23697.082      23697.082      650.23854      650.23854    
Loop time of 96.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.748 hours/ns, 10.385 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.808     | 95.808     | 95.808     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07339    | 0.07339    | 0.07339    |   0.0 |  0.08
Output  | 0.00017031 | 0.00017031 | 0.00017031 |   0.0 |  0.00
Modify  | 0.35658    | 0.35658    | 0.35658    |   0.0 |  0.37
Other   |            | 0.05596    |            |       |  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:       116696 ave      116696 max      116696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116696
Ave neighs/atom = 58.348
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.54778259868, Press = -0.815832820656344
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  -8437.4676     -8437.4676     -8507.5539     -8507.5539      271.24119      271.24119      23697.082      23697.082      650.23854      650.23854    
     31000  -8429.8647     -8429.8647     -8503.5183     -8503.5183      285.04693      285.04693      23720.254      23720.254     -162.48769     -162.48769    
Loop time of 96.3273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.758 hours/ns, 10.381 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.842     | 95.842     | 95.842     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073433   | 0.073433   | 0.073433   |   0.0 |  0.08
Output  | 0.00016851 | 0.00016851 | 0.00016851 |   0.0 |  0.00
Modify  | 0.35631    | 0.35631    | 0.35631    |   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:           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:       116642 ave      116642 max      116642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116642
Ave neighs/atom = 58.321
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.63703758404, Press = -0.0631694301171569
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  -8429.8647     -8429.8647     -8503.5183     -8503.5183      285.04693      285.04693      23720.254      23720.254     -162.48769     -162.48769    
     32000  -8438.0198     -8438.0198     -8507.9035     -8507.9035      270.45709      270.45709      23715.693      23715.693     -804.68924     -804.68924    
Loop time of 96.2551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.738 hours/ns, 10.389 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.771     | 95.771     | 95.771     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072733   | 0.072733   | 0.072733   |   0.0 |  0.08
Output  | 0.0001685  | 0.0001685  | 0.0001685  |   0.0 |  0.00
Modify  | 0.35637    | 0.35637    | 0.35637    |   0.0 |  0.37
Other   |            | 0.05522    |            |       |  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:       116696 ave      116696 max      116696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116696
Ave neighs/atom = 58.348
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.691090784212, Press = -1.72713763864925
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  -8438.0198     -8438.0198     -8507.9035     -8507.9035      270.45709      270.45709      23715.693      23715.693     -804.68924     -804.68924    
     33000  -8438.8713     -8438.8713     -8508.9176     -8508.9176      271.08627      271.08627      23691.007      23691.007      784.458        784.458      
Loop time of 96.4391 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.789 hours/ns, 10.369 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.953     | 95.953     | 95.953     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072721   | 0.072721   | 0.072721   |   0.0 |  0.08
Output  | 0.00016929 | 0.00016929 | 0.00016929 |   0.0 |  0.00
Modify  | 0.35756    | 0.35756    | 0.35756    |   0.0 |  0.37
Other   |            | 0.05558    |            |       |  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:       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 = 272.696614545563, Press = -1.49138202014318
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  -8438.8713     -8438.8713     -8508.9176     -8508.9176      271.08627      271.08627      23691.007      23691.007      784.458        784.458      
     34000  -8435.7879     -8435.7879     -8505.7771     -8505.7771      270.86507      270.86507      23704.595      23704.595      372.93655      372.93655    
Loop time of 96.4051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.779 hours/ns, 10.373 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.921     | 95.921     | 95.921     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073106   | 0.073106   | 0.073106   |   0.0 |  0.08
Output  | 0.00016901 | 0.00016901 | 0.00016901 |   0.0 |  0.00
Modify  | 0.3561     | 0.3561     | 0.3561     |   0.0 |  0.37
Other   |            | 0.05499    |            |       |  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:       116624 ave      116624 max      116624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116624
Ave neighs/atom = 58.312
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.711312427819, Press = 0.937960895683406
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   
     34000  -8435.7879     -8435.7879     -8505.7771     -8505.7771      270.86507      270.86507      23704.595      23704.595      372.93655      372.93655    
     35000  -8433.3963     -8433.3963     -8506.4367     -8506.4367      282.67403      282.67403      23751.344      23751.344     -2802.8665     -2802.8665    
Loop time of 96.0469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.680 hours/ns, 10.412 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.562     | 95.562     | 95.562     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073098   | 0.073098   | 0.073098   |   0.0 |  0.08
Output  | 0.00016778 | 0.00016778 | 0.00016778 |   0.0 |  0.00
Modify  | 0.35602    | 0.35602    | 0.35602    |   0.0 |  0.37
Other   |            | 0.05598    |            |       |  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:       116604 ave      116604 max      116604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116604
Ave neighs/atom = 58.302
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.760799554314, Press = -2.16651823376417
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   
     35000  -8433.3963     -8433.3963     -8506.4367     -8506.4367      282.67403      282.67403      23751.344      23751.344     -2802.8665     -2802.8665    
     36000  -8436.8238     -8436.8238     -8507.2306     -8507.2306      272.4817       272.4817       23679.072      23679.072      1956.3124      1956.3124    
Loop time of 96.2835 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.745 hours/ns, 10.386 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.798     | 95.798     | 95.798     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072963   | 0.072963   | 0.072963   |   0.0 |  0.08
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.35644    | 0.35644    | 0.35644    |   0.0 |  0.37
Other   |            | 0.05568    |            |       |  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:       116588 ave      116588 max      116588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116588
Ave neighs/atom = 58.294
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.828181012291, Press = -2.07263921233381
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   
     36000  -8436.8238     -8436.8238     -8507.2306     -8507.2306      272.4817       272.4817       23679.072      23679.072      1956.3124      1956.3124    
     37000  -8437.0943     -8437.0943     -8507.1197     -8507.1197      271.00547      271.00547      23700.87       23700.87       371.36145      371.36145    
Loop time of 96.1337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.704 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.073389   | 0.073389   | 0.073389   |   0.0 |  0.08
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.35525    | 0.35525    | 0.35525    |   0.0 |  0.37
Other   |            | 0.05572    |            |       |  0.06

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

Total # of neighbors = 116662
Ave neighs/atom = 58.331
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.868931508053, Press = 0.820187454703778
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   
     37000  -8437.0943     -8437.0943     -8507.1197     -8507.1197      271.00547      271.00547      23700.87       23700.87       371.36145      371.36145    
     38000  -8436.8031     -8436.8031     -8506.1265     -8506.1265      268.28862      268.28862      23732.274      23732.274     -1705.9123     -1705.9123    
Loop time of 96.2498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.736 hours/ns, 10.390 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.764     | 95.764     | 95.764     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073011   | 0.073011   | 0.073011   |   0.0 |  0.08
Output  | 0.00045049 | 0.00045049 | 0.00045049 |   0.0 |  0.00
Modify  | 0.35619    | 0.35619    | 0.35619    |   0.0 |  0.37
Other   |            | 0.05651    |            |       |  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:       116644 ave      116644 max      116644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116644
Ave neighs/atom = 58.322
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.935044262803, Press = -1.71669470158105
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   
     38000  -8436.8031     -8436.8031     -8506.1265     -8506.1265      268.28862      268.28862      23732.274      23732.274     -1705.9123     -1705.9123    
     39000  -8435.3512     -8435.3512     -8506.317      -8506.317       274.64498      274.64498      23687.246      23687.246      1599.6992      1599.6992    
Loop time of 95.9476 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.652 hours/ns, 10.422 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.464     | 95.464     | 95.464     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072315   | 0.072315   | 0.072315   |   0.0 |  0.08
Output  | 0.00017044 | 0.00017044 | 0.00017044 |   0.0 |  0.00
Modify  | 0.35536    | 0.35536    | 0.35536    |   0.0 |  0.37
Other   |            | 0.05575    |            |       |  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:       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 = 272.916715696177, Press = -1.52831902868397
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   
     39000  -8435.3512     -8435.3512     -8506.317      -8506.317       274.64498      274.64498      23687.246      23687.246      1599.6992      1599.6992    
     40000  -8432.8485     -8432.8485     -8504.5045     -8504.5045      277.31636      277.31636      23694.31       23694.31       1387.1772      1387.1772    
Loop time of 95.8384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.622 hours/ns, 10.434 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.355     | 95.355     | 95.355     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072209   | 0.072209   | 0.072209   |   0.0 |  0.08
Output  | 0.00017095 | 0.00017095 | 0.00017095 |   0.0 |  0.00
Modify  | 0.35511    | 0.35511    | 0.35511    |   0.0 |  0.37
Other   |            | 0.05596    |            |       |  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:       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 = 272.977622602836, Press = 3.30341261156884
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   
     40000  -8432.8485     -8432.8485     -8504.5045     -8504.5045      277.31636      277.31636      23694.31       23694.31       1387.1772      1387.1772    
     41000  -8436.4068     -8436.4068     -8505.7707     -8505.7707      268.44517      268.44517      23750.13       23750.13      -2832.9089     -2832.9089    
Loop time of 95.7752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.604 hours/ns, 10.441 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.292     | 95.292     | 95.292     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071875   | 0.071875   | 0.071875   |   0.0 |  0.08
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.35584    | 0.35584    | 0.35584    |   0.0 |  0.37
Other   |            | 0.05575    |            |       |  0.06

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

Total # of neighbors = 116684
Ave neighs/atom = 58.342
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.00100633413, Press = -1.27608098653536
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   
     41000  -8436.4068     -8436.4068     -8505.7707     -8505.7707      268.44517      268.44517      23750.13       23750.13      -2832.9089     -2832.9089    
     42000  -8433.8118     -8433.8118     -8505.6575     -8505.6575      278.05037      278.05037      23699.408      23699.408      860.25785      860.25785    
Loop time of 95.6956 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.582 hours/ns, 10.450 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.212     | 95.212     | 95.212     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07247    | 0.07247    | 0.07247    |   0.0 |  0.08
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.35516    | 0.35516    | 0.35516    |   0.0 |  0.37
Other   |            | 0.05609    |            |       |  0.06

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

Total # of neighbors = 116584
Ave neighs/atom = 58.292
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.084842236216, Press = -1.46174901063793
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   
     42000  -8433.8118     -8433.8118     -8505.6575     -8505.6575      278.05037      278.05037      23699.408      23699.408      860.25785      860.25785    
     43000  -8434.7797     -8434.7797     -8504.5505     -8504.5505      270.02019      270.02019      23705.879      23705.879      702.09551      702.09551    
Loop time of 95.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.606 hours/ns, 10.440 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.296     | 95.296     | 95.296     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073167   | 0.073167   | 0.073167   |   0.0 |  0.08
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.37
Other   |            | 0.05582    |            |       |  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:       116636 ave      116636 max      116636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116636
Ave neighs/atom = 58.318
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.072843731782, Press = 0.42492705038143
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   
     43000  -8434.7797     -8434.7797     -8504.5505     -8504.5505      270.02019      270.02019      23705.879      23705.879      702.09551      702.09551    
     44000  -8439.6084     -8439.6084     -8508.8642     -8508.8642      268.02714      268.02714      23723.061      23723.061     -1488.479      -1488.479     
Loop time of 95.8325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.620 hours/ns, 10.435 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.348     | 95.348     | 95.348     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072735   | 0.072735   | 0.072735   |   0.0 |  0.08
Output  | 0.0001703  | 0.0001703  | 0.0001703  |   0.0 |  0.00
Modify  | 0.35591    | 0.35591    | 0.35591    |   0.0 |  0.37
Other   |            | 0.0558     |            |       |  0.06

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

Total # of neighbors = 116688
Ave neighs/atom = 58.344
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.030660634573, Press = -0.877934288091088
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   
     44000  -8439.6084     -8439.6084     -8508.8642     -8508.8642      268.02714      268.02714      23723.061      23723.061     -1488.479      -1488.479     
     45000  -8435.3375     -8435.3375     -8508.6249     -8508.6249      283.62973      283.62973      23694.904      23694.904      689.22121      689.22121    
Loop time of 95.6696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.575 hours/ns, 10.453 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.185     | 95.185     | 95.185     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072469   | 0.072469   | 0.072469   |   0.0 |  0.08
Output  | 0.00016785 | 0.00016785 | 0.00016785 |   0.0 |  0.00
Modify  | 0.35557    | 0.35557    | 0.35557    |   0.0 |  0.37
Other   |            | 0.05595    |            |       |  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:       116556 ave      116556 max      116556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116556
Ave neighs/atom = 58.278
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.988282859684, Press = -1.55263758771999
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   
     45000  -8435.3375     -8435.3375     -8508.6249     -8508.6249      283.62973      283.62973      23694.904      23694.904      689.22121      689.22121    
     46000  -8435.1367     -8435.1367     -8506.4609     -8506.4609      276.03193      276.03193      23678.049      23678.049      2224.8215      2224.8215    
Loop time of 95.7234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.590 hours/ns, 10.447 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.24      | 95.24      | 95.24      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072309   | 0.072309   | 0.072309   |   0.0 |  0.08
Output  | 0.00016982 | 0.00016982 | 0.00016982 |   0.0 |  0.00
Modify  | 0.3553     | 0.3553     | 0.3553     |   0.0 |  0.37
Other   |            | 0.05604    |            |       |  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:       116604 ave      116604 max      116604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116604
Ave neighs/atom = 58.302
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.958993703157, Press = 1.78501343471826
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   
     46000  -8435.1367     -8435.1367     -8506.4609     -8506.4609      276.03193      276.03193      23678.049      23678.049      2224.8215      2224.8215    
     47000  -8437.0615     -8437.0615     -8506.5766     -8506.5766      269.03068      269.03068      23748.587      23748.587     -2878.5051     -2878.5051    
Loop time of 95.7931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.609 hours/ns, 10.439 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.309     | 95.309     | 95.309     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072513   | 0.072513   | 0.072513   |   0.0 |  0.08
Output  | 0.00016979 | 0.00016979 | 0.00016979 |   0.0 |  0.00
Modify  | 0.35607    | 0.35607    | 0.35607    |   0.0 |  0.37
Other   |            | 0.05587    |            |       |  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:       116708 ave      116708 max      116708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116708
Ave neighs/atom = 58.354
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.017853843853, Press = -0.564035265059979
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   
     47000  -8437.0615     -8437.0615     -8506.5766     -8506.5766      269.03068      269.03068      23748.587      23748.587     -2878.5051     -2878.5051    
     48000  -8433.6454     -8433.6454     -8505.2291     -8505.2291      277.03638      277.03638      23706.848      23706.848      475.21762      475.21762    
Loop time of 95.1653 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.435 hours/ns, 10.508 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    | 94.684     | 94.684     | 94.684     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07156    | 0.07156    | 0.07156    |   0.0 |  0.08
Output  | 0.00016139 | 0.00016139 | 0.00016139 |   0.0 |  0.00
Modify  | 0.35422    | 0.35422    | 0.35422    |   0.0 |  0.37
Other   |            | 0.05565    |            |       |  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:       116584 ave      116584 max      116584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116584
Ave neighs/atom = 58.292
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.052768624272, Press = -1.15846505724166
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   
     48000  -8433.6454     -8433.6454     -8505.2291     -8505.2291      277.03638      277.03638      23706.848      23706.848      475.21762      475.21762    
     49000  -8437.7708     -8437.7708     -8506.9129     -8506.9129      267.5874       267.5874       23692.34       23692.34       1079.7575      1079.7575    
Loop time of 92.1294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.938 ns/day, 25.591 hours/ns, 10.854 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    | 91.659     | 91.659     | 91.659     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070447   | 0.070447   | 0.070447   |   0.0 |  0.08
Output  | 0.0001611  | 0.0001611  | 0.0001611  |   0.0 |  0.00
Modify  | 0.34466    | 0.34466    | 0.34466    |   0.0 |  0.37
Other   |            | 0.05489    |            |       |  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:       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"
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.0771205042

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0