# 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.863645806908607*${_u_distance}
variable latticeconst_converted equal 2.863645806908607*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86364580690861
Lattice spacing in x,y,z = 2.8636458 2.8636458 2.8636458
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  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.636458 28.636458 28.636458)
  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_JeongParkDo_2018_PdFe__MO_924736622203_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_924736622203_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  -8494.3364     -8494.3364     -8580.4194     -8580.4194      333.15         333.15         23483.234      23483.234      3915.3848      3915.3848    
      1000  -8403.4984     -8403.4984     -8486.2159     -8486.2159      320.12518      320.12518      23777.383      23777.383     -749.85424     -749.85424    
Loop time of 60.5029 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.428 ns/day, 16.806 hours/ns, 16.528 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    | 60.422     | 60.422     | 60.422     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015313   | 0.015313   | 0.015313   |   0.0 |  0.03
Output  | 0.0001417  | 0.0001417  | 0.0001417  |   0.0 |  0.00
Modify  | 0.06046    | 0.06046    | 0.06046    |   0.0 |  0.10
Other   |            | 0.005475   |            |       |  0.01

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  -8403.4984     -8403.4984     -8486.2159     -8486.2159      320.12518      320.12518      23777.383      23777.383     -749.85424     -749.85424    
      2000  -8404.4487     -8404.4487     -8490.2147     -8490.2147      331.92322      331.92322      23790.525      23790.525     -2120.9419     -2120.9419    
Loop time of 62.9693 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.372 ns/day, 17.491 hours/ns, 15.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    | 62.889     | 62.889     | 62.889     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.02
Output  | 7.6093e-05 | 7.6093e-05 | 7.6093e-05 |   0.0 |  0.00
Modify  | 0.05957    | 0.05957    | 0.05957    |   0.0 |  0.09
Other   |            | 0.005217   |            |       |  0.01

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:       210758 ave      210758 max      210758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 210758
Ave neighs/atom = 105.379
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  -8404.4487     -8404.4487     -8490.2147     -8490.2147      331.92322      331.92322      23790.525      23790.525     -2120.9419     -2120.9419    
      3000  -8405.3518     -8405.3518     -8485.8041     -8485.8041      311.35868      311.35868      23736.038      23736.038      2212.4428      2212.4428    
Loop time of 63.1014 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.528 hours/ns, 15.848 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    | 63.022     | 63.022     | 63.022     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01488    | 0.01488    | 0.01488    |   0.0 |  0.02
Output  | 3.5677e-05 | 3.5677e-05 | 3.5677e-05 |   0.0 |  0.00
Modify  | 0.059357   | 0.059357   | 0.059357   |   0.0 |  0.09
Other   |            | 0.005199   |            |       |  0.01

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:       211382 ave      211382 max      211382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211382
Ave neighs/atom = 105.691
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  -8405.3518     -8405.3518     -8485.8041     -8485.8041      311.35868      311.35868      23736.038      23736.038      2212.4428      2212.4428    
      4000  -8403.5435     -8403.5435     -8490.1228     -8490.1228      335.07069      335.07069      23736.47       23736.47       1629.6496      1629.6496    
Loop time of 63.1831 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.551 hours/ns, 15.827 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    | 63.104     | 63.104     | 63.104     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014843   | 0.014843   | 0.014843   |   0.0 |  0.02
Output  | 3.6519e-05 | 3.6519e-05 | 3.6519e-05 |   0.0 |  0.00
Modify  | 0.059441   | 0.059441   | 0.059441   |   0.0 |  0.09
Other   |            | 0.005196   |            |       |  0.01

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:       211714 ave      211714 max      211714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211714
Ave neighs/atom = 105.857
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  -8403.5435     -8403.5435     -8490.1228     -8490.1228      335.07069      335.07069      23736.47       23736.47       1629.6496      1629.6496    
      5000  -8405.4635     -8405.4635     -8492.4819     -8492.4819      336.77038      336.77038      23778.041      23778.041     -1464.3489     -1464.3489    
Loop time of 63.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.577 hours/ns, 15.804 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    | 63.197     | 63.197     | 63.197     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014882   | 0.014882   | 0.014882   |   0.0 |  0.02
Output  | 3.0327e-05 | 3.0327e-05 | 3.0327e-05 |   0.0 |  0.00
Modify  | 0.059732   | 0.059732   | 0.059732   |   0.0 |  0.09
Other   |            | 0.005261   |            |       |  0.01

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:       211810 ave      211810 max      211810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211810
Ave neighs/atom = 105.905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.212708421511, Press = -193.200820902228
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  -8405.4635     -8405.4635     -8492.4819     -8492.4819      336.77038      336.77038      23778.041      23778.041     -1464.3489     -1464.3489    
      6000  -8402.8836     -8402.8836     -8493.2524     -8493.2524      349.73654      349.73654      23769.355      23769.355     -911.59063     -911.59063    
Loop time of 63.3702 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 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    | 63.288     | 63.288     | 63.288     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014842   | 0.014842   | 0.014842   |   0.0 |  0.02
Output  | 3.0949e-05 | 3.0949e-05 | 3.0949e-05 |   0.0 |  0.00
Modify  | 0.061823   | 0.061823   | 0.061823   |   0.0 |  0.10
Other   |            | 0.005243   |            |       |  0.01

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:       211772 ave      211772 max      211772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211772
Ave neighs/atom = 105.886
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 = 331.881459684806, Press = 15.2536463079968
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  -8402.8836     -8402.8836     -8493.2524     -8493.2524      349.73654      349.73654      23769.355      23769.355     -911.59063     -911.59063    
      7000  -8407.156      -8407.156      -8492.2959     -8492.2959      329.49997      329.49997      23749.572      23749.572      466.84471      466.84471    
Loop time of 63.3634 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.601 hours/ns, 15.782 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    | 63.282     | 63.282     | 63.282     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014901   | 0.014901   | 0.014901   |   0.0 |  0.02
Output  | 3.1139e-05 | 3.1139e-05 | 3.1139e-05 |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.10
Other   |            | 0.005229   |            |       |  0.01

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:       212270 ave      212270 max      212270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212270
Ave neighs/atom = 106.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.545857936505, Press = 20.9381080797838
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  -8407.156      -8407.156      -8492.2959     -8492.2959      329.49997      329.49997      23749.572      23749.572      466.84471      466.84471    
      8000  -8402.9807     -8402.9807     -8490.2896     -8490.2896      337.89441      337.89441      23724.84       23724.84       2617.0889      2617.0889    
Loop time of 63.3068 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.585 hours/ns, 15.796 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    | 63.225     | 63.225     | 63.225     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.02
Output  | 3.0808e-05 | 3.0808e-05 | 3.0808e-05 |   0.0 |  0.00
Modify  | 0.061742   | 0.061742   | 0.061742   |   0.0 |  0.10
Other   |            | 0.005228   |            |       |  0.01

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:       211970 ave      211970 max      211970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211970
Ave neighs/atom = 105.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.521774136472, Press = -17.0805408001025
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  -8402.9807     -8402.9807     -8490.2896     -8490.2896      337.89441      337.89441      23724.84       23724.84       2617.0889      2617.0889    
      9000  -8405.7729     -8405.7729     -8489.7825     -8489.7825      325.12577      325.12577      23787.175      23787.175     -1841.1725     -1841.1725    
Loop time of 63.3725 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 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    | 63.291     | 63.291     | 63.291     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014824   | 0.014824   | 0.014824   |   0.0 |  0.02
Output  | 3.2251e-05 | 3.2251e-05 | 3.2251e-05 |   0.0 |  0.00
Modify  | 0.061788   | 0.061788   | 0.061788   |   0.0 |  0.10
Other   |            | 0.005247   |            |       |  0.01

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:       212200 ave      212200 max      212200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212200
Ave neighs/atom = 106.1
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 = 331.930133557106, Press = -17.2093732423752
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  -8405.7729     -8405.7729     -8489.7825     -8489.7825      325.12577      325.12577      23787.175      23787.175     -1841.1725     -1841.1725    
     10000  -8405.9574     -8405.9574     -8490.0055     -8490.0055      325.27478      325.27478      23780.961      23780.961     -1520.1561     -1520.1561    
Loop time of 63.1773 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.549 hours/ns, 15.828 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    | 63.095     | 63.095     | 63.095     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.02
Output  | 3.1209e-05 | 3.1209e-05 | 3.1209e-05 |   0.0 |  0.00
Modify  | 0.061748   | 0.061748   | 0.061748   |   0.0 |  0.10
Other   |            | 0.005247   |            |       |  0.01

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:       211272 ave      211272 max      211272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211272
Ave neighs/atom = 105.636
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 = 331.952305170902, Press = 10.4162849601209
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  -8405.9574     -8405.9574     -8490.0055     -8490.0055      325.27478      325.27478      23780.961      23780.961     -1520.1561     -1520.1561    
     11000  -8402.1888     -8402.1888     -8490.074      -8490.074       340.12501      340.12501      23749.171      23749.171      918.06164      918.06164    
Loop time of 63.0898 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.525 hours/ns, 15.850 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    | 63.008     | 63.008     | 63.008     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014859   | 0.014859   | 0.014859   |   0.0 |  0.02
Output  | 3.1539e-05 | 3.1539e-05 | 3.1539e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.10
Other   |            | 0.005237   |            |       |  0.01

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:       211324 ave      211324 max      211324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211324
Ave neighs/atom = 105.662
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.08687339167, Press = 4.66828403106741
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  -8402.1888     -8402.1888     -8490.074      -8490.074       340.12501      340.12501      23749.171      23749.171      918.06164      918.06164    
     12000  -8405.7955     -8405.7955     -8490.0584     -8490.0584      326.10617      326.10617      23752.842      23752.842      519.70174      519.70174    
Loop time of 63.1049 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.529 hours/ns, 15.847 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    | 63.023     | 63.023     | 63.023     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014892   | 0.014892   | 0.014892   |   0.0 |  0.02
Output  | 3.16e-05   | 3.16e-05   | 3.16e-05   |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.10
Other   |            | 0.005226   |            |       |  0.01

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:       211942 ave      211942 max      211942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211942
Ave neighs/atom = 105.971
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 = 331.865970729331, Press = -1.53267097776534
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  -8405.7955     -8405.7955     -8490.0584     -8490.0584      326.10617      326.10617      23752.842      23752.842      519.70174      519.70174    
     13000  -8403.7579     -8403.7579     -8489.2385     -8489.2385      330.81892      330.81892      23764.473      23764.473     -69.998986     -69.998986    
Loop time of 63.0745 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.521 hours/ns, 15.854 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    | 62.993     | 62.993     | 62.993     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.02
Output  | 3.5086e-05 | 3.5086e-05 | 3.5086e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.10
Other   |            | 0.005243   |            |       |  0.01

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:       211838 ave      211838 max      211838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211838
Ave neighs/atom = 105.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.051178054204, Press = -1.14702309498226
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  -8403.7579     -8403.7579     -8489.2385     -8489.2385      330.81892      330.81892      23764.473      23764.473     -69.998986     -69.998986    
     14000  -8399.6215     -8399.6215     -8487.0939     -8487.0939      338.52733      338.52733      23776.042      23776.042     -468.62802     -468.62802    
Loop time of 63.1635 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.545 hours/ns, 15.832 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    | 63.082     | 63.082     | 63.082     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014932   | 0.014932   | 0.014932   |   0.0 |  0.02
Output  | 3.155e-05  | 3.155e-05  | 3.155e-05  |   0.0 |  0.00
Modify  | 0.06171    | 0.06171    | 0.06171    |   0.0 |  0.10
Other   |            | 0.005254   |            |       |  0.01

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:       211676 ave      211676 max      211676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211676
Ave neighs/atom = 105.838
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.296187908691, Press = -1.40903939592849
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  -8399.6215     -8399.6215     -8487.0939     -8487.0939      338.52733      338.52733      23776.042      23776.042     -468.62802     -468.62802    
     15000  -8405.3432     -8405.3432     -8491.9237     -8491.9237      335.07548      335.07548      23762.521      23762.521     -345.6958      -345.6958     
Loop time of 63.0716 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.520 hours/ns, 15.855 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    | 62.99      | 62.99      | 62.99      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014871   | 0.014871   | 0.014871   |   0.0 |  0.02
Output  | 3.21e-05   | 3.21e-05   | 3.21e-05   |   0.0 |  0.00
Modify  | 0.061762   | 0.061762   | 0.061762   |   0.0 |  0.10
Other   |            | 0.005227   |            |       |  0.01

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:       211040 ave      211040 max      211040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211040
Ave neighs/atom = 105.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.648768266865, Press = 0.469332209780262
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  -8405.3432     -8405.3432     -8491.9237     -8491.9237      335.07548      335.07548      23762.521      23762.521     -345.6958      -345.6958     
     16000  -8399.0998     -8399.0998     -8486.6621     -8486.6621      338.87539      338.87539      23758.991      23758.991      785.39635      785.39635    
Loop time of 63.1265 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.535 hours/ns, 15.841 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    | 63.045     | 63.045     | 63.045     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.02
Output  | 3.207e-05  | 3.207e-05  | 3.207e-05  |   0.0 |  0.00
Modify  | 0.061701   | 0.061701   | 0.061701   |   0.0 |  0.10
Other   |            | 0.005231   |            |       |  0.01

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:       211740 ave      211740 max      211740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211740
Ave neighs/atom = 105.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 = 332.89851310797, Press = -0.357415516676442
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  -8399.0998     -8399.0998     -8486.6621     -8486.6621      338.87539      338.87539      23758.991      23758.991      785.39635      785.39635    
     17000  -8404.5904     -8404.5904     -8489.0384     -8489.0384      326.8225       326.8225       23758.992      23758.992      294.77835      294.77835    
Loop time of 63.1226 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.534 hours/ns, 15.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    | 63.041     | 63.041     | 63.041     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014793   | 0.014793   | 0.014793   |   0.0 |  0.02
Output  | 3.0468e-05 | 3.0468e-05 | 3.0468e-05 |   0.0 |  0.00
Modify  | 0.061748   | 0.061748   | 0.061748   |   0.0 |  0.10
Other   |            | 0.005216   |            |       |  0.01

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:       211400 ave      211400 max      211400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211400
Ave neighs/atom = 105.7
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.058317486058, Press = -3.01989222219007
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  -8404.5904     -8404.5904     -8489.0384     -8489.0384      326.8225       326.8225       23758.992      23758.992      294.77835      294.77835    
     18000  -8403.6135     -8403.6135     -8489.0173     -8489.0173      330.5214       330.5214       23787.762      23787.762     -1634.4814     -1634.4814    
Loop time of 63.0951 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.526 hours/ns, 15.849 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    | 63.013     | 63.013     | 63.013     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014997   | 0.014997   | 0.014997   |   0.0 |  0.02
Output  | 2.9556e-05 | 2.9556e-05 | 2.9556e-05 |   0.0 |  0.00
Modify  | 0.061735   | 0.061735   | 0.061735   |   0.0 |  0.10
Other   |            | 0.005225   |            |       |  0.01

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:       211742 ave      211742 max      211742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211742
Ave neighs/atom = 105.871
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.052906230706, Press = -1.73284157556551
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  -8403.6135     -8403.6135     -8489.0173     -8489.0173      330.5214       330.5214       23787.762      23787.762     -1634.4814     -1634.4814    
     19000  -8407.6912     -8407.6912     -8493.3061     -8493.3061      331.33847      331.33847      23754.935      23754.935     -72.851553     -72.851553    
Loop time of 63.2221 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.562 hours/ns, 15.817 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.14      | 63.14      | 63.14      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.02
Output  | 3.1429e-05 | 3.1429e-05 | 3.1429e-05 |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.10
Other   |            | 0.00527    |            |       |  0.01

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:       211440 ave      211440 max      211440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211440
Ave neighs/atom = 105.72
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.976732761383, Press = 5.37875908694834
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  -8407.6912     -8407.6912     -8493.3061     -8493.3061      331.33847      331.33847      23754.935      23754.935     -72.851553     -72.851553    
     20000  -8403.2618     -8403.2618     -8489.8613     -8489.8613      335.14898      335.14898      23718.333      23718.333      3189.3934      3189.3934    
Loop time of 63.2449 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.568 hours/ns, 15.812 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.163     | 63.163     | 63.163     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.02
Output  | 3.1059e-05 | 3.1059e-05 | 3.1059e-05 |   0.0 |  0.00
Modify  | 0.061651   | 0.061651   | 0.061651   |   0.0 |  0.10
Other   |            | 0.005214   |            |       |  0.01

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:       212096 ave      212096 max      212096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212096
Ave neighs/atom = 106.048
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.853447742708, Press = -1.40142471702481
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  -8403.2618     -8403.2618     -8489.8613     -8489.8613      335.14898      335.14898      23718.333      23718.333      3189.3934      3189.3934    
     21000  -8408.961      -8408.961      -8493.3875     -8493.3875      326.7391       326.7391       23779.691      23779.691     -1861.5297     -1861.5297    
Loop time of 63.2586 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.572 hours/ns, 15.808 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.177     | 63.177     | 63.177     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.02
Output  | 3.1289e-05 | 3.1289e-05 | 3.1289e-05 |   0.0 |  0.00
Modify  | 0.061697   | 0.061697   | 0.061697   |   0.0 |  0.10
Other   |            | 0.005233   |            |       |  0.01

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:       212478 ave      212478 max      212478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212478
Ave neighs/atom = 106.239
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.68389515393, Press = -3.52478517727836
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  -8408.961      -8408.961      -8493.3875     -8493.3875      326.7391       326.7391       23779.691      23779.691     -1861.5297     -1861.5297    
     22000  -8402.432      -8402.432      -8489.35       -8489.35        336.38163      336.38163      23786.739      23786.739     -1629.9736     -1629.9736    
Loop time of 63.0965 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.527 hours/ns, 15.849 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.015     | 63.015     | 63.015     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014839   | 0.014839   | 0.014839   |   0.0 |  0.02
Output  | 3.0187e-05 | 3.0187e-05 | 3.0187e-05 |   0.0 |  0.00
Modify  | 0.06165    | 0.06165    | 0.06165    |   0.0 |  0.10
Other   |            | 0.005221   |            |       |  0.01

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:       211674 ave      211674 max      211674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211674
Ave neighs/atom = 105.837
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.660099565948, Press = 2.61788632919414
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  -8402.432      -8402.432      -8489.35       -8489.35        336.38163      336.38163      23786.739      23786.739     -1629.9736     -1629.9736    
     23000  -8400.74       -8400.74       -8486.7902     -8486.7902      333.02332      333.02332      23732.346      23732.346      2712.7183      2712.7183    
Loop time of 63.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.513 hours/ns, 15.862 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.963     | 62.963     | 62.963     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014887   | 0.014887   | 0.014887   |   0.0 |  0.02
Output  | 3.0457e-05 | 3.0457e-05 | 3.0457e-05 |   0.0 |  0.00
Modify  | 0.0618     | 0.0618     | 0.0618     |   0.0 |  0.10
Other   |            | 0.005229   |            |       |  0.01

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:       211124 ave      211124 max      211124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211124
Ave neighs/atom = 105.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.681889244458, Press = 1.29944393419984
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  -8400.74       -8400.74       -8486.7902     -8486.7902      333.02332      333.02332      23732.346      23732.346      2712.7183      2712.7183    
     24000  -8402.4791     -8402.4791     -8489.4682     -8489.4682      336.65703      336.65703      23764.712      23764.712     -120.05977     -120.05977    
Loop time of 63.1512 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.542 hours/ns, 15.835 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.069     | 63.069     | 63.069     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014907   | 0.014907   | 0.014907   |   0.0 |  0.02
Output  | 3.4084e-05 | 3.4084e-05 | 3.4084e-05 |   0.0 |  0.00
Modify  | 0.061688   | 0.061688   | 0.061688   |   0.0 |  0.10
Other   |            | 0.005233   |            |       |  0.01

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:       212012 ave      212012 max      212012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212012
Ave neighs/atom = 106.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.75021068333, Press = -4.43441580228088
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  -8402.4791     -8402.4791     -8489.4682     -8489.4682      336.65703      336.65703      23764.712      23764.712     -120.05977     -120.05977    
     25000  -8400.3517     -8400.3517     -8487.8804     -8487.8804      338.74508      338.74508      23794.33       23794.33      -1855.2932     -1855.2932    
Loop time of 63.1347 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.537 hours/ns, 15.839 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.053     | 63.053     | 63.053     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01486    | 0.01486    | 0.01486    |   0.0 |  0.02
Output  | 3.0547e-05 | 3.0547e-05 | 3.0547e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.10
Other   |            | 0.005227   |            |       |  0.01

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:       211506 ave      211506 max      211506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211506
Ave neighs/atom = 105.753
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.775848050581, Press = 0.452283492930439
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  -8400.3517     -8400.3517     -8487.8804     -8487.8804      338.74508      338.74508      23794.33       23794.33      -1855.2932     -1855.2932    
     26000  -8404.941      -8404.941      -8492.8824     -8492.8824      340.34243      340.34243      23748.048      23748.048      526.58425      526.58425    
Loop time of 63.0356 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.371 ns/day, 17.510 hours/ns, 15.864 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.954     | 62.954     | 62.954     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014811   | 0.014811   | 0.014811   |   0.0 |  0.02
Output  | 3.0308e-05 | 3.0308e-05 | 3.0308e-05 |   0.0 |  0.00
Modify  | 0.061811   | 0.061811   | 0.061811   |   0.0 |  0.10
Other   |            | 0.005216   |            |       |  0.01

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:       211104 ave      211104 max      211104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211104
Ave neighs/atom = 105.552
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.914485181386, Press = 1.4245038741027
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  -8404.941      -8404.941      -8492.8824     -8492.8824      340.34243      340.34243      23748.048      23748.048      526.58425      526.58425    
     27000  -8404.5606     -8404.5606     -8489.5876     -8489.5876      329.06343      329.06343      23749.894      23749.894      928.80796      928.80796    
Loop time of 63.3129 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.587 hours/ns, 15.795 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.231     | 63.231     | 63.231     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014861   | 0.014861   | 0.014861   |   0.0 |  0.02
Output  | 3.1289e-05 | 3.1289e-05 | 3.1289e-05 |   0.0 |  0.00
Modify  | 0.061709   | 0.061709   | 0.061709   |   0.0 |  0.10
Other   |            | 0.005292   |            |       |  0.01

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:       211950 ave      211950 max      211950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211950
Ave neighs/atom = 105.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.971053590719, Press = -1.06148329579088
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  -8404.5606     -8404.5606     -8489.5876     -8489.5876      329.06343      329.06343      23749.894      23749.894      928.80796      928.80796    
     28000  -8407.0417     -8407.0417     -8491.8261     -8491.8261      328.12449      328.12449      23779.918      23779.918     -1587.8437     -1587.8437    
Loop time of 63.0242 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.371 ns/day, 17.507 hours/ns, 15.867 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.942     | 62.942     | 62.942     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014824   | 0.014824   | 0.014824   |   0.0 |  0.02
Output  | 3.1439e-05 | 3.1439e-05 | 3.1439e-05 |   0.0 |  0.00
Modify  | 0.061774   | 0.061774   | 0.061774   |   0.0 |  0.10
Other   |            | 0.005238   |            |       |  0.01

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:       211710 ave      211710 max      211710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211710
Ave neighs/atom = 105.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.99958549899, Press = -2.12502846116204
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  -8407.0417     -8407.0417     -8491.8261     -8491.8261      328.12449      328.12449      23779.918      23779.918     -1587.8437     -1587.8437    
     29000  -8403.9359     -8403.9359     -8490.6253     -8490.6253      335.49691      335.49691      23766.328      23766.328     -400.58453     -400.58453    
Loop time of 63.1614 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.545 hours/ns, 15.832 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.08      | 63.08      | 63.08      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.02
Output  | 3.1068e-05 | 3.1068e-05 | 3.1068e-05 |   0.0 |  0.00
Modify  | 0.061688   | 0.061688   | 0.061688   |   0.0 |  0.10
Other   |            | 0.005227   |            |       |  0.01

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:       211604 ave      211604 max      211604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211604
Ave neighs/atom = 105.802
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.882166795783, Press = 2.72691416819881
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  -8403.9359     -8403.9359     -8490.6253     -8490.6253      335.49691      335.49691      23766.328      23766.328     -400.58453     -400.58453    
     30000  -8406.3925     -8406.3925     -8492.2279     -8492.2279      332.19165      332.19165      23701.928      23701.928      3867.7069      3867.7069    
Loop time of 63.1358 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.538 hours/ns, 15.839 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.054     | 63.054     | 63.054     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015003   | 0.015003   | 0.015003   |   0.0 |  0.02
Output  | 3.2251e-05 | 3.2251e-05 | 3.2251e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.10
Other   |            | 0.005216   |            |       |  0.01

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:       211620 ave      211620 max      211620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211620
Ave neighs/atom = 105.81
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.887569542221, Press = -0.557052129569041
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  -8406.3925     -8406.3925     -8492.2279     -8492.2279      332.19165      332.19165      23701.928      23701.928      3867.7069      3867.7069    
     31000  -8405.791      -8405.791      -8492.4215     -8492.4215      335.26928      335.26928      23773.172      23773.172     -1079.1244     -1079.1244    
Loop time of 63.2953 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.582 hours/ns, 15.799 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.213     | 63.213     | 63.213     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.02
Output  | 3.0758e-05 | 3.0758e-05 | 3.0758e-05 |   0.0 |  0.00
Modify  | 0.06161    | 0.06161    | 0.06161    |   0.0 |  0.10
Other   |            | 0.005238   |            |       |  0.01

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:       212702 ave      212702 max      212702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212702
Ave neighs/atom = 106.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 = 332.840811368042, Press = -3.40716449807772
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  -8405.791      -8405.791      -8492.4215     -8492.4215      335.26928      335.26928      23773.172      23773.172     -1079.1244     -1079.1244    
     32000  -8406.2331     -8406.2331     -8490.4768     -8490.4768      326.03177      326.03177      23774.817      23774.817     -959.05979     -959.05979    
Loop time of 63.2592 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.572 hours/ns, 15.808 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.177     | 63.177     | 63.177     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.02
Output  | 3.1559e-05 | 3.1559e-05 | 3.1559e-05 |   0.0 |  0.00
Modify  | 0.061702   | 0.061702   | 0.061702   |   0.0 |  0.10
Other   |            | 0.00519    |            |       |  0.01

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:       211880 ave      211880 max      211880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211880
Ave neighs/atom = 105.94
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.900789697565, Press = 1.0861496875021
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  -8406.2331     -8406.2331     -8490.4768     -8490.4768      326.03177      326.03177      23774.817      23774.817     -959.05979     -959.05979    
     33000  -8402.4742     -8402.4742     -8488.7303     -8488.7303      333.81991      333.81991      23751.437      23751.437      1023.396       1023.396     
Loop time of 63.0724 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.520 hours/ns, 15.855 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.99      | 62.99      | 62.99      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015131   | 0.015131   | 0.015131   |   0.0 |  0.02
Output  | 3.1129e-05 | 3.1129e-05 | 3.1129e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.10
Other   |            | 0.005147   |            |       |  0.01

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:       211450 ave      211450 max      211450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211450
Ave neighs/atom = 105.725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876872909112, Press = 0.592493838836932
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  -8402.4742     -8402.4742     -8488.7303     -8488.7303      333.81991      333.81991      23751.437      23751.437      1023.396       1023.396     
     34000  -8405.1259     -8405.1259     -8489.9814     -8489.9814      328.39968      328.39968      23744.327      23744.327      1313.916       1313.916     
Loop time of 63.1109 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.531 hours/ns, 15.845 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.029     | 63.029     | 63.029     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015014   | 0.015014   | 0.015014   |   0.0 |  0.02
Output  | 3.1118e-05 | 3.1118e-05 | 3.1118e-05 |   0.0 |  0.00
Modify  | 0.061605   | 0.061605   | 0.061605   |   0.0 |  0.10
Other   |            | 0.005153   |            |       |  0.01

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:       211438 ave      211438 max      211438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211438
Ave neighs/atom = 105.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.972835873264, Press = -0.818358207567755
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  -8405.1259     -8405.1259     -8489.9814     -8489.9814      328.39968      328.39968      23744.327      23744.327      1313.916       1313.916     
     35000  -8402.9715     -8402.9715     -8487.9914     -8487.9914      329.03582      329.03582      23782.846      23782.846     -1147.3635     -1147.3635    
Loop time of 63.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.535 hours/ns, 15.841 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.045     | 63.045     | 63.045     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014945   | 0.014945   | 0.014945   |   0.0 |  0.02
Output  | 3.3273e-05 | 3.3273e-05 | 3.3273e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.10
Other   |            | 0.005155   |            |       |  0.01

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:       212080 ave      212080 max      212080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212080
Ave neighs/atom = 106.04
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.99965850034, Press = -1.67688982956459
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  -8402.9715     -8402.9715     -8487.9914     -8487.9914      329.03582      329.03582      23782.846      23782.846     -1147.3635     -1147.3635    
     36000  -8405.8464     -8405.8464     -8490.5444     -8490.5444      327.79009      327.79009      23769.832      23769.832     -714.85777     -714.85777    
Loop time of 63.053 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.515 hours/ns, 15.860 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.971     | 62.971     | 62.971     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.02
Output  | 3.0628e-05 | 3.0628e-05 | 3.0628e-05 |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.10
Other   |            | 0.005167   |            |       |  0.01

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:       211190 ave      211190 max      211190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211190
Ave neighs/atom = 105.595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.924588393192, Press = 1.62454171538099
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  -8405.8464     -8405.8464     -8490.5444     -8490.5444      327.79009      327.79009      23769.832      23769.832     -714.85777     -714.85777    
     37000  -8405.6735     -8405.6735     -8491.113      -8491.113       330.65979      330.65979      23698.204      23698.204      4240.2093      4240.2093    
Loop time of 63.2567 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.571 hours/ns, 15.809 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.175     | 63.175     | 63.175     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014953   | 0.014953   | 0.014953   |   0.0 |  0.02
Output  | 3.3734e-05 | 3.3734e-05 | 3.3734e-05 |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.10
Other   |            | 0.00515    |            |       |  0.01

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:       211680 ave      211680 max      211680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211680
Ave neighs/atom = 105.84
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.977448200537, Press = 0.231423431944785
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  -8405.6735     -8405.6735     -8491.113      -8491.113       330.65979      330.65979      23698.204      23698.204      4240.2093      4240.2093    
     38000  -8401.8632     -8401.8632     -8487.9326     -8487.9326      333.09739      333.09739      23775.063      23775.063     -627.87617     -627.87617    
Loop time of 63.2052 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.557 hours/ns, 15.821 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.123     | 63.123     | 63.123     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014908   | 0.014908   | 0.014908   |   0.0 |  0.02
Output  | 3.0017e-05 | 3.0017e-05 | 3.0017e-05 |   0.0 |  0.00
Modify  | 0.061676   | 0.061676   | 0.061676   |   0.0 |  0.10
Other   |            | 0.005182   |            |       |  0.01

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:       212656 ave      212656 max      212656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212656
Ave neighs/atom = 106.328
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.029235715891, Press = -2.90713357575815
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  -8401.8632     -8401.8632     -8487.9326     -8487.9326      333.09739      333.09739      23775.063      23775.063     -627.87617     -627.87617    
     39000  -8403.6017     -8403.6017     -8491.52       -8491.52        340.25302      340.25302      23786.05       23786.05      -1914.3573     -1914.3573    
Loop time of 63.2009 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.556 hours/ns, 15.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.119     | 63.119     | 63.119     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014909   | 0.014909   | 0.014909   |   0.0 |  0.02
Output  | 3.0477e-05 | 3.0477e-05 | 3.0477e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.10
Other   |            | 0.005447   |            |       |  0.01

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:       211158 ave      211158 max      211158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0