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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.4489947895 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_075279800195_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8489.4196     -8489.4196     -8559.9991     -8559.9991      273.15         273.15         23173.449      23173.449      3253.1805      3253.1805    
      1000  -8424.6309     -8424.6309     -8497.0737     -8497.0737      280.36142      280.36142      23492.459      23492.459     -3347.2687     -3347.2687    
Loop time of 22.2031 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.891 ns/day, 6.168 hours/ns, 45.039 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 22.122     | 22.122     | 22.122     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015101   | 0.015101   | 0.015101   |   0.0 |  0.07
Output  | 0.00013894 | 0.00013894 | 0.00013894 |   0.0 |  0.00
Modify  | 0.059894   | 0.059894   | 0.059894   |   0.0 |  0.27
Other   |            | 0.005619   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8424.6309     -8424.6309     -8497.0737     -8497.0737      280.36142      280.36142      23492.459      23492.459     -3347.2687     -3347.2687    
      2000  -8419.493      -8419.493      -8489.4605     -8489.4605      270.78156      270.78156      23464.992      23464.992      700.23682      700.23682    
Loop time of 23.2003 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.724 ns/day, 6.445 hours/ns, 43.103 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.121     | 23.121     | 23.121     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014835   | 0.014835   | 0.014835   |   0.0 |  0.06
Output  | 4.3111e-05 | 4.3111e-05 | 4.3111e-05 |   0.0 |  0.00
Modify  | 0.059398   | 0.059398   | 0.059398   |   0.0 |  0.26
Other   |            | 0.005485   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216430 ave      216430 max      216430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216430
Ave neighs/atom = 108.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8419.493      -8419.493      -8489.4605     -8489.4605      270.78156      270.78156      23464.992      23464.992      700.23682      700.23682    
      3000  -8424.9576     -8424.9576     -8495.0986     -8495.0986      271.4529       271.4529       23444.824      23444.824      792.67557      792.67557    
Loop time of 23.2201 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.721 ns/day, 6.450 hours/ns, 43.066 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.14      | 23.14      | 23.14      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015103   | 0.015103   | 0.015103   |   0.0 |  0.07
Output  | 3.8091e-05 | 3.8091e-05 | 3.8091e-05 |   0.0 |  0.00
Modify  | 0.059301   | 0.059301   | 0.059301   |   0.0 |  0.26
Other   |            | 0.005443   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216046 ave      216046 max      216046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216046
Ave neighs/atom = 108.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8424.9576     -8424.9576     -8495.0986     -8495.0986      271.4529       271.4529       23444.824      23444.824      792.67557      792.67557    
      4000  -8420.7173     -8420.7173     -8492.4015     -8492.4015      277.42517      277.42517      23469.184      23469.184     -210.66082     -210.66082    
Loop time of 23.2631 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.714 ns/day, 6.462 hours/ns, 42.987 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.183     | 23.183     | 23.183     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.06
Output  | 3.8122e-05 | 3.8122e-05 | 3.8122e-05 |   0.0 |  0.00
Modify  | 0.05932    | 0.05932    | 0.05932    |   0.0 |  0.25
Other   |            | 0.005376   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       217008 ave      217008 max      217008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217008
Ave neighs/atom = 108.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8420.7173     -8420.7173     -8492.4015     -8492.4015      277.42517      277.42517      23469.184      23469.184     -210.66082     -210.66082    
      5000  -8422.8164     -8422.8164     -8491.6824     -8491.6824      266.5188       266.5188       23483.382      23483.382     -1218.1541     -1218.1541    
Loop time of 23.3418 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.484 hours/ns, 42.842 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.262     | 23.262     | 23.262     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.06
Output  | 2.9064e-05 | 2.9064e-05 | 2.9064e-05 |   0.0 |  0.00
Modify  | 0.059593   | 0.059593   | 0.059593   |   0.0 |  0.26
Other   |            | 0.005383   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216350 ave      216350 max      216350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216350
Ave neighs/atom = 108.175
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 = 268.301670814444, Press = -135.650344984655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8422.8164     -8422.8164     -8491.6824     -8491.6824      266.5188       266.5188       23483.382      23483.382     -1218.1541     -1218.1541    
      6000  -8422.2057     -8422.2057     -8492.9783     -8492.9783      273.89736      273.89736      23432.967      23432.967      2319.9362      2319.9362    
Loop time of 23.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.710 ns/day, 6.469 hours/ns, 42.941 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.206     | 23.206     | 23.206     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.06
Output  | 2.9185e-05 | 2.9185e-05 | 2.9185e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.26
Other   |            | 0.005413   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216040 ave      216040 max      216040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216040
Ave neighs/atom = 108.02
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.254201826842, Press = -0.958241180222971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8422.2057     -8422.2057     -8492.9783     -8492.9783      273.89736      273.89736      23432.967      23432.967      2319.9362      2319.9362    
      7000  -8421.7728     -8421.7728     -8492.2823     -8492.2823      272.87895      272.87895      23503.119      23503.119     -2734.9727     -2734.9727    
Loop time of 23.2308 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.719 ns/day, 6.453 hours/ns, 43.046 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.149     | 23.149     | 23.149     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015007   | 0.015007   | 0.015007   |   0.0 |  0.06
Output  | 2.172e-05  | 2.172e-05  | 2.172e-05  |   0.0 |  0.00
Modify  | 0.061573   | 0.061573   | 0.061573   |   0.0 |  0.27
Other   |            | 0.005398   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216684 ave      216684 max      216684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216684
Ave neighs/atom = 108.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 = 272.646586588121, Press = 20.1454353544275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8421.7728     -8421.7728     -8492.2823     -8492.2823      272.87895      272.87895      23503.119      23503.119     -2734.9727     -2734.9727    
      8000  -8423.1462     -8423.1462     -8493.5104     -8493.5104      272.31667      272.31667      23445.899      23445.899      1445.8026      1445.8026    
Loop time of 23.3171 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.887 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.235     | 23.235     | 23.235     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.06
Output  | 3.0437e-05 | 3.0437e-05 | 3.0437e-05 |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.26
Other   |            | 0.005412   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216282 ave      216282 max      216282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216282
Ave neighs/atom = 108.141
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.652218608125, Press = -20.3643636518762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8423.1462     -8423.1462     -8493.5104     -8493.5104      272.31667      272.31667      23445.899      23445.899      1445.8026      1445.8026    
      9000  -8421.5643     -8421.5643     -8492.8733     -8492.8733      275.97313      275.97313      23468.141      23468.141     -251.24942     -251.24942    
Loop time of 23.3171 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.887 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.235     | 23.235     | 23.235     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01491    | 0.01491    | 0.01491    |   0.0 |  0.06
Output  | 2.1861e-05 | 2.1861e-05 | 2.1861e-05 |   0.0 |  0.00
Modify  | 0.061605   | 0.061605   | 0.061605   |   0.0 |  0.26
Other   |            | 0.005422   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216926 ave      216926 max      216926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216926
Ave neighs/atom = 108.463
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.526621473913, Press = 11.4518450205818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8421.5643     -8421.5643     -8492.8733     -8492.8733      275.97313      275.97313      23468.141      23468.141     -251.24942     -251.24942    
     10000  -8424.3293     -8424.3293     -8492.8486     -8492.8486      265.1768       265.1768       23457.483      23457.483      359.21511      359.21511    
Loop time of 23.3331 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.481 hours/ns, 42.858 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.251     | 23.251     | 23.251     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014912   | 0.014912   | 0.014912   |   0.0 |  0.06
Output  | 2.9255e-05 | 2.9255e-05 | 2.9255e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.26
Other   |            | 0.005393   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216782 ave      216782 max      216782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216782
Ave neighs/atom = 108.391
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.457320275955, Press = -3.65892605697608
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8424.3293     -8424.3293     -8492.8486     -8492.8486      265.1768       265.1768       23457.483      23457.483      359.21511      359.21511    
     11000  -8420.9399     -8420.9399     -8490.9941     -8490.9941      271.11691      271.11691      23456.173      23456.173      1179.065       1179.065     
Loop time of 23.3045 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.707 ns/day, 6.473 hours/ns, 42.910 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.222     | 23.222     | 23.222     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.06
Output  | 2.1481e-05 | 2.1481e-05 | 2.1481e-05 |   0.0 |  0.00
Modify  | 0.061623   | 0.061623   | 0.061623   |   0.0 |  0.26
Other   |            | 0.005407   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216702 ave      216702 max      216702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216702
Ave neighs/atom = 108.351
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.574197055891, Press = 4.82522508997238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8420.9399     -8420.9399     -8490.9941     -8490.9941      271.11691      271.11691      23456.173      23456.173      1179.065       1179.065     
     12000  -8422.3509     -8422.3509     -8494.0276     -8494.0276      277.39621      277.39621      23498.312      23498.312     -2831.1309     -2831.1309    
Loop time of 23.3071 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.707 ns/day, 6.474 hours/ns, 42.905 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.225     | 23.225     | 23.225     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01492    | 0.01492    | 0.01492    |   0.0 |  0.06
Output  | 2.1941e-05 | 2.1941e-05 | 2.1941e-05 |   0.0 |  0.00
Modify  | 0.061612   | 0.061612   | 0.061612   |   0.0 |  0.26
Other   |            | 0.005391   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216482 ave      216482 max      216482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216482
Ave neighs/atom = 108.241
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.505977036383, Press = -8.63863830178819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8422.3509     -8422.3509     -8494.0276     -8494.0276      277.39621      277.39621      23498.312      23498.312     -2831.1309     -2831.1309    
     13000  -8420.6274     -8420.6274     -8492.9579     -8492.9579      279.92653      279.92653      23429.69       23429.69       2782.6441      2782.6441    
Loop time of 23.2435 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.717 ns/day, 6.457 hours/ns, 43.023 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.162     | 23.162     | 23.162     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.06
Output  | 2.9605e-05 | 2.9605e-05 | 2.9605e-05 |   0.0 |  0.00
Modify  | 0.06161    | 0.06161    | 0.06161    |   0.0 |  0.27
Other   |            | 0.005422   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216208 ave      216208 max      216208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216208
Ave neighs/atom = 108.104
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.833542402671, Press = 3.20020890077115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8420.6274     -8420.6274     -8492.9579     -8492.9579      279.92653      279.92653      23429.69       23429.69       2782.6441      2782.6441    
     14000  -8421.8309     -8421.8309     -8492.8859     -8492.8859      274.99055      274.99055      23494.323      23494.323     -2194.5481     -2194.5481    
Loop time of 23.3133 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.894 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.231     | 23.231     | 23.231     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.06
Output  | 2.1821e-05 | 2.1821e-05 | 2.1821e-05 |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.26
Other   |            | 0.00541    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216904 ave      216904 max      216904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216904
Ave neighs/atom = 108.452
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.885869962836, Press = 1.24013373820587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8421.8309     -8421.8309     -8492.8859     -8492.8859      274.99055      274.99055      23494.323      23494.323     -2194.5481     -2194.5481    
     15000  -8424.1717     -8424.1717     -8494.6197     -8494.6197      272.64116      272.64116      23452.268      23452.268      488.64741      488.64741    
Loop time of 23.3031 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.708 ns/day, 6.473 hours/ns, 42.913 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.221     | 23.221     | 23.221     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.06
Output  | 3.5016e-05 | 3.5016e-05 | 3.5016e-05 |   0.0 |  0.00
Modify  | 0.06155    | 0.06155    | 0.06155    |   0.0 |  0.26
Other   |            | 0.005437   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216196 ave      216196 max      216196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216196
Ave neighs/atom = 108.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.772011203148, Press = 0.42189632976866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8424.1717     -8424.1717     -8494.6197     -8494.6197      272.64116      272.64116      23452.268      23452.268      488.64741      488.64741    
     16000  -8422.0618     -8422.0618     -8492.8805     -8492.8805      274.0757       274.0757       23458.063      23458.063      505.3801       505.3801     
Loop time of 23.308 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.707 ns/day, 6.474 hours/ns, 42.904 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.226     | 23.226     | 23.226     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.06
Output  | 2.1631e-05 | 2.1631e-05 | 2.1631e-05 |   0.0 |  0.00
Modify  | 0.061566   | 0.061566   | 0.061566   |   0.0 |  0.26
Other   |            | 0.005388   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216798 ave      216798 max      216798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216798
Ave neighs/atom = 108.399
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.617076393081, Press = 1.56949143533752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8422.0618     -8422.0618     -8492.8805     -8492.8805      274.0757       274.0757       23458.063      23458.063      505.3801       505.3801     
     17000  -8419.4884     -8419.4884     -8490.3453     -8490.3453      274.22322      274.22322      23491.293      23491.293     -1248.0536     -1248.0536    
Loop time of 23.3313 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.481 hours/ns, 42.861 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.249     | 23.249     | 23.249     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014891   | 0.014891   | 0.014891   |   0.0 |  0.06
Output  | 2.1821e-05 | 2.1821e-05 | 2.1821e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.26
Other   |            | 0.005387   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216708 ave      216708 max      216708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216708
Ave neighs/atom = 108.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.530973832173, Press = -3.28435915738831
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8419.4884     -8419.4884     -8490.3453     -8490.3453      274.22322      274.22322      23491.293      23491.293     -1248.0536     -1248.0536    
     18000  -8421.0627     -8421.0627     -8494.4848     -8494.4848      284.1513       284.1513       23426.271      23426.271      2626.9352      2626.9352    
Loop time of 23.3176 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.886 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.236     | 23.236     | 23.236     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.06
Output  | 3.217e-05  | 3.217e-05  | 3.217e-05  |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.26
Other   |            | 0.005421   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216184 ave      216184 max      216184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216184
Ave neighs/atom = 108.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.643304693253, Press = -0.722865379807077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8421.0627     -8421.0627     -8494.4848     -8494.4848      284.1513       284.1513       23426.271      23426.271      2626.9352      2626.9352    
     19000  -8425.1009     -8425.1009     -8495.3567     -8495.3567      271.89712      271.89712      23494.626      23494.626     -2849.8664     -2849.8664    
Loop time of 23.4307 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.687 ns/day, 6.509 hours/ns, 42.679 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.349     | 23.349     | 23.349     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014907   | 0.014907   | 0.014907   |   0.0 |  0.06
Output  | 2.151e-05  | 2.151e-05  | 2.151e-05  |   0.0 |  0.00
Modify  | 0.06163    | 0.06163    | 0.06163    |   0.0 |  0.26
Other   |            | 0.005399   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       217260 ave      217260 max      217260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217260
Ave neighs/atom = 108.63
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.559898943143, Press = 3.55548566608112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8425.1009     -8425.1009     -8495.3567     -8495.3567      271.89712      271.89712      23494.626      23494.626     -2849.8664     -2849.8664    
     20000  -8422.2716     -8422.2716     -8494.371      -8494.371       279.03204      279.03204      23457.41       23457.41       210.18004      210.18004    
Loop time of 23.3616 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.489 hours/ns, 42.805 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.28      | 23.28      | 23.28      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015022   | 0.015022   | 0.015022   |   0.0 |  0.06
Output  | 3.0197e-05 | 3.0197e-05 | 3.0197e-05 |   0.0 |  0.00
Modify  | 0.061582   | 0.061582   | 0.061582   |   0.0 |  0.26
Other   |            | 0.005406   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216578 ave      216578 max      216578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216578
Ave neighs/atom = 108.289
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.460773002561, Press = -2.632768329878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8422.2716     -8422.2716     -8494.371      -8494.371       279.03204      279.03204      23457.41       23457.41       210.18004      210.18004    
     21000  -8422.0844     -8422.0844     -8492.8164     -8492.8164      273.74031      273.74031      23463.352      23463.352      53.186995      53.186995    
Loop time of 23.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.697 ns/day, 6.492 hours/ns, 42.786 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.29      | 23.29      | 23.29      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014944   | 0.014944   | 0.014944   |   0.0 |  0.06
Output  | 2.1411e-05 | 2.1411e-05 | 2.1411e-05 |   0.0 |  0.00
Modify  | 0.061588   | 0.061588   | 0.061588   |   0.0 |  0.26
Other   |            | 0.005387   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216742 ave      216742 max      216742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216742
Ave neighs/atom = 108.371
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.468805990337, Press = 2.24903519893579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8422.0844     -8422.0844     -8492.8164     -8492.8164      273.74031      273.74031      23463.352      23463.352      53.186995      53.186995    
     22000  -8422.1849     -8422.1849     -8494.0298     -8494.0298      278.04694      278.04694      23486.388      23486.388     -1701.3863     -1701.3863    
Loop time of 23.3562 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.488 hours/ns, 42.815 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.274     | 23.274     | 23.274     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014945   | 0.014945   | 0.014945   |   0.0 |  0.06
Output  | 2.1741e-05 | 2.1741e-05 | 2.1741e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.26
Other   |            | 0.005387   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216598 ave      216598 max      216598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216598
Ave neighs/atom = 108.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 = 273.402764794532, Press = -1.92748585890689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8422.1849     -8422.1849     -8494.0298     -8494.0298      278.04694      278.04694      23486.388      23486.388     -1701.3863     -1701.3863    
     23000  -8423.6153     -8423.6153     -8493.0808     -8493.0808      268.83877      268.83877      23438.882      23438.882      1925.6102      1925.6102    
Loop time of 23.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.710 ns/day, 6.469 hours/ns, 42.939 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.207     | 23.207     | 23.207     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014881   | 0.014881   | 0.014881   |   0.0 |  0.06
Output  | 3.1549e-05 | 3.1549e-05 | 3.1549e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.26
Other   |            | 0.005431   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216532 ave      216532 max      216532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216532
Ave neighs/atom = 108.266
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.395774335888, Press = 0.83898874708195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8423.6153     -8423.6153     -8493.0808     -8493.0808      268.83877      268.83877      23438.882      23438.882      1925.6102      1925.6102    
     24000  -8421.942      -8421.942      -8492.5314     -8492.5314      273.18852      273.18852      23500.297      23500.297     -2595.3044     -2595.3044    
Loop time of 23.2798 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.711 ns/day, 6.467 hours/ns, 42.956 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.198     | 23.198     | 23.198     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.06
Output  | 2.149e-05  | 2.149e-05  | 2.149e-05  |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.26
Other   |            | 0.005405   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216976 ave      216976 max      216976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216976
Ave neighs/atom = 108.488
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.331904233515, Press = 0.665062190921166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8421.942      -8421.942      -8492.5314     -8492.5314      273.18852      273.18852      23500.297      23500.297     -2595.3044     -2595.3044    
     25000  -8422.4678     -8422.4678     -8493.0572     -8493.0572      273.18832      273.18832      23436.773      23436.773      2193.8613      2193.8613    
Loop time of 23.2533 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.716 ns/day, 6.459 hours/ns, 43.005 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.171     | 23.171     | 23.171     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.06
Output  | 2.16e-05   | 2.16e-05   | 2.16e-05   |   0.0 |  0.00
Modify  | 0.061495   | 0.061495   | 0.061495   |   0.0 |  0.26
Other   |            | 0.005398   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216054 ave      216054 max      216054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216054
Ave neighs/atom = 108.027
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.189698041125, Press = -2.50906840020397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8422.4678     -8422.4678     -8493.0572     -8493.0572      273.18832      273.18832      23436.773      23436.773      2193.8613      2193.8613    
     26000  -8422.2184     -8422.2184     -8494.3858     -8494.3858      279.29548      279.29548      23479.526      23479.526     -1395.7238     -1395.7238    
Loop time of 23.4023 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.692 ns/day, 6.501 hours/ns, 42.731 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.32      | 23.32      | 23.32      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.06
Output  | 3.4505e-05 | 3.4505e-05 | 3.4505e-05 |   0.0 |  0.00
Modify  | 0.061635   | 0.061635   | 0.061635   |   0.0 |  0.26
Other   |            | 0.005423   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       217042 ave      217042 max      217042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217042
Ave neighs/atom = 108.521
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.129710769723, Press = 5.28688942245864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8422.2184     -8422.2184     -8494.3858     -8494.3858      279.29548      279.29548      23479.526      23479.526     -1395.7238     -1395.7238    
     27000  -8421.5609     -8421.5609     -8491.0258     -8491.0258      268.83634      268.83634      23472.777      23472.777     -159.19195     -159.19195    
Loop time of 23.3537 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.487 hours/ns, 42.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.271     | 23.271     | 23.271     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015136   | 0.015136   | 0.015136   |   0.0 |  0.06
Output  | 2.1651e-05 | 2.1651e-05 | 2.1651e-05 |   0.0 |  0.00
Modify  | 0.061593   | 0.061593   | 0.061593   |   0.0 |  0.26
Other   |            | 0.005412   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216628 ave      216628 max      216628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216628
Ave neighs/atom = 108.314
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.012454139158, Press = -1.80434704270042
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8421.5609     -8421.5609     -8491.0258     -8491.0258      268.83634      268.83634      23472.777      23472.777     -159.19195     -159.19195    
     28000  -8424.2241     -8424.2241     -8494.6949     -8494.6949      272.72904      272.72904      23447.756      23447.756      786.76424      786.76424    
Loop time of 23.3394 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.846 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.257     | 23.257     | 23.257     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.06
Output  | 3.5347e-05 | 3.5347e-05 | 3.5347e-05 |   0.0 |  0.00
Modify  | 0.061662   | 0.061662   | 0.061662   |   0.0 |  0.26
Other   |            | 0.005395   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216424 ave      216424 max      216424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216424
Ave neighs/atom = 108.212
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.986918088301, Press = 1.96865644121108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8424.2241     -8424.2241     -8494.6949     -8494.6949      272.72904      272.72904      23447.756      23447.756      786.76424      786.76424    
     29000  -8420.1061     -8420.1061     -8492.8299     -8492.8299      281.44841      281.44841      23492.962      23492.962     -2061.2399     -2061.2399    
Loop time of 23.2988 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.708 ns/day, 6.472 hours/ns, 42.921 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.217     | 23.217     | 23.217     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.06
Output  | 2.1461e-05 | 2.1461e-05 | 2.1461e-05 |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.26
Other   |            | 0.005388   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216812 ave      216812 max      216812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216812
Ave neighs/atom = 108.406
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.979694481334, Press = -1.47803187517416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8420.1061     -8420.1061     -8492.8299     -8492.8299      281.44841      281.44841      23492.962      23492.962     -2061.2399     -2061.2399    
     30000  -8423.1316     -8423.1316     -8493.9416     -8493.9416      274.04193      274.04193      23431.698      23431.698      2278.0795      2278.0795    
Loop time of 23.2814 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.711 ns/day, 6.467 hours/ns, 42.953 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.199     | 23.199     | 23.199     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015096   | 0.015096   | 0.015096   |   0.0 |  0.06
Output  | 2.1701e-05 | 2.1701e-05 | 2.1701e-05 |   0.0 |  0.00
Modify  | 0.061586   | 0.061586   | 0.061586   |   0.0 |  0.26
Other   |            | 0.00538    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216086 ave      216086 max      216086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216086
Ave neighs/atom = 108.043
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.898598405614, Press = -0.136522828864902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8423.1316     -8423.1316     -8493.9416     -8493.9416      274.04193      274.04193      23431.698      23431.698      2278.0795      2278.0795    
     31000  -8422.9231     -8422.9231     -8492.3687     -8492.3687      268.76156      268.76156      23505.514      23505.514     -3062.3309     -3062.3309    
Loop time of 23.2786 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.712 ns/day, 6.466 hours/ns, 42.958 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.197     | 23.197     | 23.197     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014879   | 0.014879   | 0.014879   |   0.0 |  0.06
Output  | 2.9204e-05 | 2.9204e-05 | 2.9204e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.26
Other   |            | 0.00539    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216988 ave      216988 max      216988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216988
Ave neighs/atom = 108.494
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.845126754562, Press = 2.79741918398786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8422.9231     -8422.9231     -8492.3687     -8492.3687      268.76156      268.76156      23505.514      23505.514     -3062.3309     -3062.3309    
     32000  -8420.1533     -8420.1533     -8491.8903     -8491.8903      277.62977      277.62977      23455.648      23455.648      929.72767      929.72767    
Loop time of 23.2558 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.715 ns/day, 6.460 hours/ns, 43.000 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.174     | 23.174     | 23.174     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01497    | 0.01497    | 0.01497    |   0.0 |  0.06
Output  | 2.16e-05   | 2.16e-05   | 2.16e-05   |   0.0 |  0.00
Modify  | 0.061562   | 0.061562   | 0.061562   |   0.0 |  0.26
Other   |            | 0.005392   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       215740 ave      215740 max      215740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215740
Ave neighs/atom = 107.87
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.86966794015, Press = -2.62592385376612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8420.1533     -8420.1533     -8491.8903     -8491.8903      277.62977      277.62977      23455.648      23455.648      929.72767      929.72767    
     33000  -8423.7596     -8423.7596     -8493.0916     -8493.0916      268.32202      268.32202      23457.666      23457.666      456.25888      456.25888    
Loop time of 23.3033 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.708 ns/day, 6.473 hours/ns, 42.912 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.221     | 23.221     | 23.221     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.06
Output  | 2.9134e-05 | 2.9134e-05 | 2.9134e-05 |   0.0 |  0.00
Modify  | 0.061569   | 0.061569   | 0.061569   |   0.0 |  0.26
Other   |            | 0.005393   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216508 ave      216508 max      216508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216508
Ave neighs/atom = 108.254
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.851117236182, Press = 1.80296004471613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8423.7596     -8423.7596     -8493.0916     -8493.0916      268.32202      268.32202      23457.666      23457.666      456.25888      456.25888    
     34000  -8424.1977     -8424.1977     -8495.1073     -8495.1073      274.42779      274.42779      23488.395      23488.395     -2265.5958     -2265.5958    
Loop time of 23.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.712 ns/day, 6.466 hours/ns, 42.957 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.197     | 23.197     | 23.197     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014973   | 0.014973   | 0.014973   |   0.0 |  0.06
Output  | 2.125e-05  | 2.125e-05  | 2.125e-05  |   0.0 |  0.00
Modify  | 0.061649   | 0.061649   | 0.061649   |   0.0 |  0.26
Other   |            | 0.005383   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216620 ave      216620 max      216620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216620
Ave neighs/atom = 108.31
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.829998170614, Press = -0.351750190781706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8424.1977     -8424.1977     -8495.1073     -8495.1073      274.42779      274.42779      23488.395      23488.395     -2265.5958     -2265.5958    
     35000  -8421.6855     -8421.6855     -8494.8176     -8494.8176      283.02897      283.02897      23450.049      23450.049      801.20288      801.20288    
Loop time of 23.3944 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.693 ns/day, 6.498 hours/ns, 42.745 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.312     | 23.312     | 23.312     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.06
Output  | 2.1731e-05 | 2.1731e-05 | 2.1731e-05 |   0.0 |  0.00
Modify  | 0.061555   | 0.061555   | 0.061555   |   0.0 |  0.26
Other   |            | 0.005385   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216468 ave      216468 max      216468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216468
Ave neighs/atom = 108.234
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.795519715987, Press = -0.138944246153462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8421.6855     -8421.6855     -8494.8176     -8494.8176      283.02897      283.02897      23450.049      23450.049      801.20288      801.20288    
     36000  -8423.6391     -8423.6391     -8494.6323     -8494.6323      274.75117      274.75117      23483.661      23483.661     -1710.273      -1710.273     
Loop time of 23.4043 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.692 ns/day, 6.501 hours/ns, 42.727 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.322     | 23.322     | 23.322     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014949   | 0.014949   | 0.014949   |   0.0 |  0.06
Output  | 3.1339e-05 | 3.1339e-05 | 3.1339e-05 |   0.0 |  0.00
Modify  | 0.061587   | 0.061587   | 0.061587   |   0.0 |  0.26
Other   |            | 0.005398   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       217140 ave      217140 max      217140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217140
Ave neighs/atom = 108.57
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.792445926222, Press = 1.12704842492406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8423.6391     -8423.6391     -8494.6323     -8494.6323      274.75117      274.75117      23483.661      23483.661     -1710.273      -1710.273     
     37000  -8425.4236     -8425.4236     -8494.0978     -8494.0978      265.7763       265.7763       23433.496      23433.496      1857.4246      1857.4246    
Loop time of 23.3131 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.894 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.231     | 23.231     | 23.231     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.06
Output  | 2.1481e-05 | 2.1481e-05 | 2.1481e-05 |   0.0 |  0.00
Modify  | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.26
Other   |            | 0.005405   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216644 ave      216644 max      216644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216644
Ave neighs/atom = 108.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.78229476014, Press = -2.07116225758942
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8425.4236     -8425.4236     -8494.0978     -8494.0978      265.7763       265.7763       23433.496      23433.496      1857.4246      1857.4246    
     38000  -8421.7806     -8421.7806     -8492.0582     -8492.0582      271.98142      271.98142      23464.219      23464.219      269.91591      269.91591    
Loop time of 23.3446 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.701 ns/day, 6.485 hours/ns, 42.837 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.263     | 23.263     | 23.263     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.06
Output  | 2.8173e-05 | 2.8173e-05 | 2.8173e-05 |   0.0 |  0.00
Modify  | 0.061574   | 0.061574   | 0.061574   |   0.0 |  0.26
Other   |            | 0.00541    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216960 ave      216960 max      216960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216960
Ave neighs/atom = 108.48
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.715711741916, Press = 2.81011104240671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8421.7806     -8421.7806     -8492.0582     -8492.0582      271.98142      271.98142      23464.219      23464.219      269.91591      269.91591    
     39000  -8425.2552     -8425.2552     -8493.4903     -8493.4903      264.07695      264.07695      23463.859      23463.859     -48.46034      -48.46034     
Loop time of 23.3136 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.893 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.232     | 23.232     | 23.232     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.06
Output  | 2.144e-05  | 2.144e-05  | 2.144e-05  |   0.0 |  0.00
Modify  | 0.061566   | 0.061566   | 0.061566   |   0.0 |  0.26
Other   |            | 0.005403   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216624 ave      216624 max      216624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216624
Ave neighs/atom = 108.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.685405460365, Press = -0.52066500184994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8425.2552     -8425.2552     -8493.4903     -8493.4903      264.07695      264.07695      23463.859      23463.859     -48.46034      -48.46034     
     40000  -8420.7404     -8420.7404     -8491.5072     -8491.5072      273.87492      273.87492      23461.059      23461.059      720.66622      720.66622    
Loop time of 23.2734 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.712 ns/day, 6.465 hours/ns, 42.967 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.191     | 23.191     | 23.191     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.06
Output  | 2.2012e-05 | 2.2012e-05 | 2.2012e-05 |   0.0 |  0.00
Modify  | 0.061582   | 0.061582   | 0.061582   |   0.0 |  0.26
Other   |            | 0.005392   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216606 ave      216606 max      216606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216606
Ave neighs/atom = 108.303
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.677815928474, Press = 0.753200273363316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8420.7404     -8420.7404     -8491.5072     -8491.5072      273.87492      273.87492      23461.059      23461.059      720.66622      720.66622    
     41000  -8419.3655     -8419.3655     -8491.3638     -8491.3638      278.64094      278.64094      23470.874      23470.874      77.092592      77.092592    
Loop time of 23.2943 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.709 ns/day, 6.471 hours/ns, 42.929 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.212     | 23.212     | 23.212     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.06
Output  | 2.9595e-05 | 2.9595e-05 | 2.9595e-05 |   0.0 |  0.00
Modify  | 0.061565   | 0.061565   | 0.061565   |   0.0 |  0.26
Other   |            | 0.005407   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216366 ave      216366 max      216366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216366
Ave neighs/atom = 108.183
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.692218565792, Press = 0.289846194727748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8419.3655     -8419.3655     -8491.3638     -8491.3638      278.64094      278.64094      23470.874      23470.874      77.092592      77.092592    
     42000  -8422.8682     -8422.8682     -8492.3986     -8492.3986      269.08999      269.08999      23466.604      23466.604      70.000927      70.000927    
Loop time of 23.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.482 hours/ns, 42.856 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.252     | 23.252     | 23.252     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.06
Output  | 2.136e-05  | 2.136e-05  | 2.136e-05  |   0.0 |  0.00
Modify  | 0.061493   | 0.061493   | 0.061493   |   0.0 |  0.26
Other   |            | 0.005399   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216370 ave      216370 max      216370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216370
Ave neighs/atom = 108.185
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.766664317759, Press = 0.469482409553961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8422.8682     -8422.8682     -8492.3986     -8492.3986      269.08999      269.08999      23466.604      23466.604      70.000927      70.000927    
     43000  -8418.8061     -8418.8061     -8493.0005     -8493.0005      287.13978      287.13978      23465.688      23465.688      92.653721      92.653721    
Loop time of 23.3228 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.479 hours/ns, 42.876 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.241     | 23.241     | 23.241     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014952   | 0.014952   | 0.014952   |   0.0 |  0.06
Output  | 2.1711e-05 | 2.1711e-05 | 2.1711e-05 |   0.0 |  0.00
Modify  | 0.061526   | 0.061526   | 0.061526   |   0.0 |  0.26
Other   |            | 0.005404   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216580 ave      216580 max      216580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216580
Ave neighs/atom = 108.29
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.82363804779, Press = -0.419969443177884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8418.8061     -8418.8061     -8493.0005     -8493.0005      287.13978      287.13978      23465.688      23465.688      92.653721      92.653721    
     44000  -8422.0244     -8422.0244     -8492.6033     -8492.6033      273.14774      273.14774      23467.813      23467.813     -319.87343     -319.87343    
Loop time of 23.3173 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.887 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.235     | 23.235     | 23.235     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014949   | 0.014949   | 0.014949   |   0.0 |  0.06
Output  | 2.9966e-05 | 2.9966e-05 | 2.9966e-05 |   0.0 |  0.00
Modify  | 0.061565   | 0.061565   | 0.061565   |   0.0 |  0.26
Other   |            | 0.005383   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216670 ave      216670 max      216670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216670
Ave neighs/atom = 108.335
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.82666045487, Press = 1.09698841827965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8422.0244     -8422.0244     -8492.6033     -8492.6033      273.14774      273.14774      23467.813      23467.813     -319.87343     -319.87343    
     45000  -8420.2648     -8420.2648     -8492.3353     -8492.3353      278.92033      278.92033      23487.117      23487.117     -1500.2938     -1500.2938    
Loop time of 23.3259 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.704 ns/day, 6.479 hours/ns, 42.871 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.244     | 23.244     | 23.244     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.06
Output  | 2.1691e-05 | 2.1691e-05 | 2.1691e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.26
Other   |            | 0.005388   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216386 ave      216386 max      216386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216386
Ave neighs/atom = 108.193
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.862172825681, Press = -1.21445836446578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8420.2648     -8420.2648     -8492.3353     -8492.3353      278.92033      278.92033      23487.117      23487.117     -1500.2938     -1500.2938    
     46000  -8423.6676     -8423.6676     -8493.0989     -8493.0989      268.70605      268.70605      23423.724      23423.724      3153.0235      3153.0235    
Loop time of 23.3437 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.701 ns/day, 6.484 hours/ns, 42.838 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.262     | 23.262     | 23.262     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015059   | 0.015059   | 0.015059   |   0.0 |  0.06
Output  | 2.9546e-05 | 2.9546e-05 | 2.9546e-05 |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.26
Other   |            | 0.005398   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216220 ave      216220 max      216220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216220
Ave neighs/atom = 108.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.861652370505, Press = 1.52611637845386
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8423.6676     -8423.6676     -8493.0989     -8493.0989      268.70605      268.70605      23423.724      23423.724      3153.0235      3153.0235    
     47000  -8425.0756     -8425.0756     -8494.671      -8494.671       269.34128      269.34128      23495.48       23495.48      -2796.4149     -2796.4149    
Loop time of 23.3205 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.881 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.239     | 23.239     | 23.239     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014915   | 0.014915   | 0.014915   |   0.0 |  0.06
Output  | 2.1631e-05 | 2.1631e-05 | 2.1631e-05 |   0.0 |  0.00
Modify  | 0.061579   | 0.061579   | 0.061579   |   0.0 |  0.26
Other   |            | 0.00538    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216964 ave      216964 max      216964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216964
Ave neighs/atom = 108.482
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.877417067746, Press = -0.136514430534228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8425.0756     -8425.0756     -8494.671      -8494.671       269.34128      269.34128      23495.48       23495.48      -2796.4149     -2796.4149    
     48000  -8421.5679     -8421.5679     -8492.8414     -8492.8414      275.83564      275.83564      23460.879      23460.879      203.81673      203.81673    
Loop time of 23.3605 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.489 hours/ns, 42.807 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.279     | 23.279     | 23.279     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.06
Output  | 2.1591e-05 | 2.1591e-05 | 2.1591e-05 |   0.0 |  0.00
Modify  | 0.061537   | 0.061537   | 0.061537   |   0.0 |  0.26
Other   |            | 0.005389   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216548 ave      216548 max      216548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216548
Ave neighs/atom = 108.274
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.81594175624, Press = -0.208064920928927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8421.5679     -8421.5679     -8492.8414     -8492.8414      275.83564      275.83564      23460.879      23460.879      203.81673      203.81673    
     49000  -8422.6765     -8422.6765     -8494.0588     -8494.0588      276.25685      276.25685      23461.969      23461.969     -71.436645     -71.436645    
Loop time of 23.2967 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.709 ns/day, 6.471 hours/ns, 42.925 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.215     | 23.215     | 23.215     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015091   | 0.015091   | 0.015091   |   0.0 |  0.06
Output  | 3.1269e-05 | 3.1269e-05 | 3.1269e-05 |   0.0 |  0.00
Modify  | 0.061587   | 0.061587   | 0.061587   |   0.0 |  0.26
Other   |            | 0.005391   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216342 ave      216342 max      216342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216342
Ave neighs/atom = 108.171
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.818795122861, Press = 0.619066405364325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8422.6765     -8422.6765     -8494.0588     -8494.0588      276.25685      276.25685      23461.969      23461.969     -71.436645     -71.436645    
     50000  -8421.5431     -8421.5431     -8493.9839     -8493.9839      280.35323      280.35323      23479.091      23479.091     -1315.756      -1315.756     
Loop time of 23.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.709 ns/day, 6.471 hours/ns, 42.929 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.212     | 23.212     | 23.212     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.06
Output  | 2.163e-05  | 2.163e-05  | 2.163e-05  |   0.0 |  0.00
Modify  | 0.061527   | 0.061527   | 0.061527   |   0.0 |  0.26
Other   |            | 0.005388   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216708 ave      216708 max      216708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216708
Ave neighs/atom = 108.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 = 272.868343863513, Press = -0.224407707479166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8421.5431     -8421.5431     -8493.9839     -8493.9839      280.35323      280.35323      23479.091      23479.091     -1315.756      -1315.756     
     51000  -8421.7919     -8421.7919     -8491.7653     -8491.7653      270.80429      270.80429      23445.478      23445.478      1716.6234      1716.6234    
Loop time of 23.2691 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.713 ns/day, 6.464 hours/ns, 42.976 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.187     | 23.187     | 23.187     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014931   | 0.014931   | 0.014931   |   0.0 |  0.06
Output  | 2.8553e-05 | 2.8553e-05 | 2.8553e-05 |   0.0 |  0.00
Modify  | 0.06162    | 0.06162    | 0.06162    |   0.0 |  0.26
Other   |            | 0.005401   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216428 ave      216428 max      216428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216428
Ave neighs/atom = 108.214
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.884824514933, Press = -0.0207396139089183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8421.7919     -8421.7919     -8491.7653     -8491.7653      270.80429      270.80429      23445.478      23445.478      1716.6234      1716.6234    
     52000  -8422.5306     -8422.5306     -8494.0304     -8494.0304      276.7118       276.7118       23504.045      23504.045     -3132.8307     -3132.8307    
Loop time of 23.3295 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.480 hours/ns, 42.864 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.248     | 23.248     | 23.248     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.06
Output  | 2.165e-05  | 2.165e-05  | 2.165e-05  |   0.0 |  0.00
Modify  | 0.061562   | 0.061562   | 0.061562   |   0.0 |  0.26
Other   |            | 0.005414   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216670 ave      216670 max      216670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216670
Ave neighs/atom = 108.335
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.946708685646, Press = 0.459912356077797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8422.5306     -8422.5306     -8494.0304     -8494.0304      276.7118       276.7118       23504.045      23504.045     -3132.8307     -3132.8307    
     53000  -8420.6014     -8420.6014     -8491.7814     -8491.7814      275.47395      275.47395      23432.213      23432.213      2783.0384      2783.0384    
Loop time of 23.2776 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.712 ns/day, 6.466 hours/ns, 42.960 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.196     | 23.196     | 23.196     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.06
Output  | 2.2121e-05 | 2.2121e-05 | 2.2121e-05 |   0.0 |  0.00
Modify  | 0.061554   | 0.061554   | 0.061554   |   0.0 |  0.26
Other   |            | 0.005395   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216206 ave      216206 max      216206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216206
Ave neighs/atom = 108.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.961676733361, Press = -0.808803357783446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8420.6014     -8420.6014     -8491.7814     -8491.7814      275.47395      275.47395      23432.213      23432.213      2783.0384      2783.0384    
     54000  -8423.5712     -8423.5712     -8493.6039     -8493.6039      271.03394      271.03394      23472.41       23472.41      -774.74012     -774.74012    
Loop time of 23.3245 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.704 ns/day, 6.479 hours/ns, 42.873 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.243     | 23.243     | 23.243     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.06
Output  | 3.0608e-05 | 3.0608e-05 | 3.0608e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.26
Other   |            | 0.00539    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216950 ave      216950 max      216950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216950
Ave neighs/atom = 108.475
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.963663872428, Press = 0.982239499817406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8423.5712     -8423.5712     -8493.6039     -8493.6039      271.03394      271.03394      23472.41       23472.41      -774.74012     -774.74012    
     55000  -8421.8267     -8421.8267     -8491.2192     -8491.2192      268.55606      268.55606      23461.309      23461.309      588.24107      588.24107    
Loop time of 23.2566 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.715 ns/day, 6.460 hours/ns, 42.999 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.175     | 23.175     | 23.175     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.06
Output  | 2.1421e-05 | 2.1421e-05 | 2.1421e-05 |   0.0 |  0.00
Modify  | 0.061518   | 0.061518   | 0.061518   |   0.0 |  0.26
Other   |            | 0.005391   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216502 ave      216502 max      216502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216502
Ave neighs/atom = 108.251
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.995291166582, Press = -0.298622867860502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8421.8267     -8421.8267     -8491.2192     -8491.2192      268.55606      268.55606      23461.309      23461.309      588.24107      588.24107    
     56000  -8421.3092     -8421.3092     -8492.819      -8492.819       276.7501       276.7501       23465.56       23465.56      -156.64601     -156.64601    
Loop time of 23.2462 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.717 ns/day, 6.457 hours/ns, 43.018 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.164     | 23.164     | 23.164     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014901   | 0.014901   | 0.014901   |   0.0 |  0.06
Output  | 2.8143e-05 | 2.8143e-05 | 2.8143e-05 |   0.0 |  0.00
Modify  | 0.06159    | 0.06159    | 0.06159    |   0.0 |  0.26
Other   |            | 0.005384   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216316 ave      216316 max      216316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216316
Ave neighs/atom = 108.158
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.001777809653, Press = 0.351925902222309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8421.3092     -8421.3092     -8492.819      -8492.819       276.7501       276.7501       23465.56       23465.56      -156.64601     -156.64601    
     57000  -8421.7849     -8421.7849     -8490.8995     -8490.8995      267.48064      267.48064      23460.165      23460.165      650.3447       650.3447     
Loop time of 23.3155 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.477 hours/ns, 42.890 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.234     | 23.234     | 23.234     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.06
Output  | 2.142e-05  | 2.142e-05  | 2.142e-05  |   0.0 |  0.00
Modify  | 0.061526   | 0.061526   | 0.061526   |   0.0 |  0.26
Other   |            | 0.005398   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       216366 ave      216366 max      216366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216366
Ave neighs/atom = 108.183
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
23465.1677724315

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0