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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.863657340407371*${_u_distance}
variable latticeconst_converted equal 2.863657340407371*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365734040737
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636573 28.636573 28.636573)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.636573 28.636573 28.636573)
  create_atoms CPU = 0.003 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_LeeLeeKim_2006_FeN__MO_432861766738_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

variable temp_converted equal 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_432861766738_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8493.9171     -8493.9171     -8580          -8580           333.15         333.15         23483.518      23483.518      3915.3602      3915.3602    
      1000  -8403.2191     -8403.2191     -8485.7345     -8485.7345      319.34322      319.34322      23777.874      23777.874     -774.30946     -774.30946    
Loop time of 106.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.638 hours/ns, 9.372 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    | 106.17     | 106.17     | 106.17     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07883    | 0.07883    | 0.07883    |   0.0 |  0.07
Output  | 0.00021148 | 0.00021148 | 0.00021148 |   0.0 |  0.00
Modify  | 0.39013    | 0.39013    | 0.39013    |   0.0 |  0.37
Other   |            | 0.06124    |            |       |  0.06

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

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

Performance: 0.864 ns/day, 27.781 hours/ns, 9.999 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.539     | 99.539     | 99.539     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073939   | 0.073939   | 0.073939   |   0.0 |  0.07
Output  | 0.00021607 | 0.00021607 | 0.00021607 |   0.0 |  0.00
Modify  | 0.34371    | 0.34371    | 0.34371    |   0.0 |  0.34
Other   |            | 0.05575    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116986 ave      116986 max      116986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.850 ns/day, 28.241 hours/ns, 9.836 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.19     | 101.19     | 101.19     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074434   | 0.074434   | 0.074434   |   0.0 |  0.07
Output  | 0.00020362 | 0.00020362 | 0.00020362 |   0.0 |  0.00
Modify  | 0.35134    | 0.35134    | 0.35134    |   0.0 |  0.35
Other   |            | 0.05635    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116824 ave      116824 max      116824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.879 ns/day, 27.292 hours/ns, 10.178 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.788     | 97.788     | 97.788     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072499   | 0.072499   | 0.072499   |   0.0 |  0.07
Output  | 0.0002419  | 0.0002419  | 0.0002419  |   0.0 |  0.00
Modify  | 0.3349     | 0.3349     | 0.3349     |   0.0 |  0.34
Other   |            | 0.05534    |            |       |  0.06

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

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

Performance: 0.880 ns/day, 27.278 hours/ns, 10.183 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.736     | 97.736     | 97.736     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072183   | 0.072183   | 0.072183   |   0.0 |  0.07
Output  | 0.00020237 | 0.00020237 | 0.00020237 |   0.0 |  0.00
Modify  | 0.33658    | 0.33658    | 0.33658    |   0.0 |  0.34
Other   |            | 0.05509    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116884 ave      116884 max      116884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116884
Ave neighs/atom = 58.442
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.271763731045, Press = -406.186639383158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8405.4713     -8405.4713     -8492.918      -8492.918       338.42746      338.42746      23775.81       23775.81      -1484.0279     -1484.0279    
      6000  -8403.0184     -8403.0184     -8490.2576     -8490.2576      337.62463      337.62463      23760.648      23760.648     -3.7148173     -3.7148173    
Loop time of 98.4239 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.340 hours/ns, 10.160 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.941     | 97.941     | 97.941     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072136   | 0.072136   | 0.072136   |   0.0 |  0.07
Output  | 0.00016642 | 0.00016642 | 0.00016642 |   0.0 |  0.00
Modify  | 0.35558    | 0.35558    | 0.35558    |   0.0 |  0.36
Other   |            | 0.055      |            |       |  0.06

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

Total # of neighbors = 116752
Ave neighs/atom = 58.376
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.794216061294, Press = 13.0057102591213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8403.0184     -8403.0184     -8490.2576     -8490.2576      337.62463      337.62463      23760.648      23760.648     -3.7148173     -3.7148173    
      7000  -8404.0415     -8404.0415     -8490.7759     -8490.7759      335.67114      335.67114      23763.668      23763.668     -354.90252     -354.90252    
Loop time of 110.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.559 hours/ns, 9.090 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    | 109.45     | 109.45     | 109.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080612   | 0.080612   | 0.080612   |   0.0 |  0.07
Output  | 0.00016578 | 0.00016578 | 0.00016578 |   0.0 |  0.00
Modify  | 0.41991    | 0.41991    | 0.41991    |   0.0 |  0.38
Other   |            | 0.0612     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116794 ave      116794 max      116794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116794
Ave neighs/atom = 58.397
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.874100227258, Press = -16.3591272315833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8404.0415     -8404.0415     -8490.7759     -8490.7759      335.67114      335.67114      23763.668      23763.668     -354.90252     -354.90252    
      8000  -8401.1428     -8401.1428     -8488.6013     -8488.6013      338.47347      338.47347      23787.589      23787.589     -1671.7471     -1671.7471    
Loop time of 97.5503 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.097 hours/ns, 10.251 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.066     | 97.066     | 97.066     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071818   | 0.071818   | 0.071818   |   0.0 |  0.07
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.3559     | 0.3559     | 0.3559     |   0.0 |  0.36
Other   |            | 0.05647    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116828 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414
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.883625912602, Press = 7.3998166570474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8401.1428     -8401.1428     -8488.6013     -8488.6013      338.47347      338.47347      23787.589      23787.589     -1671.7471     -1671.7471    
      9000  -8405.1185     -8405.1185     -8487.9676     -8487.9676      320.63474      320.63474      23733.829      23733.829      2104.7604      2104.7604    
Loop time of 97.9193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.200 hours/ns, 10.212 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.435     | 97.435     | 97.435     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071762   | 0.071762   | 0.071762   |   0.0 |  0.07
Output  | 0.00016899 | 0.00016899 | 0.00016899 |   0.0 |  0.00
Modify  | 0.3557     | 0.3557     | 0.3557     |   0.0 |  0.36
Other   |            | 0.05623    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2954 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116888 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444
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.864809708596, Press = 15.6011555279443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8405.1185     -8405.1185     -8487.9676     -8487.9676      320.63474      320.63474      23733.829      23733.829      2104.7604      2104.7604    
     10000  -8402.8072     -8402.8072     -8488.778      -8488.778       332.71606      332.71606      23733.922      23733.922      2009.2303      2009.2303    
Loop time of 98.7949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.443 hours/ns, 10.122 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.309     | 98.309     | 98.309     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073331   | 0.073331   | 0.073331   |   0.0 |  0.07
Output  | 0.00017151 | 0.00017151 | 0.00017151 |   0.0 |  0.00
Modify  | 0.35739    | 0.35739    | 0.35739    |   0.0 |  0.36
Other   |            | 0.05521    |            |       |  0.06

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

Total # of neighbors = 116946
Ave neighs/atom = 58.473
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.020731828832, Press = -14.2592635124779
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8402.8072     -8402.8072     -8488.778      -8488.778       332.71606      332.71606      23733.922      23733.922      2009.2303      2009.2303    
     11000  -8404.0108     -8404.0108     -8490.2925     -8490.2925      333.91908      333.91908      23802.371      23802.371     -3030.3272     -3030.3272    
Loop time of 98.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.387 hours/ns, 10.143 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.107     | 98.107     | 98.107     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073516   | 0.073516   | 0.073516   |   0.0 |  0.07
Output  | 0.00017286 | 0.00017286 | 0.00017286 |   0.0 |  0.00
Modify  | 0.35822    | 0.35822    | 0.35822    |   0.0 |  0.36
Other   |            | 0.05454    |            |       |  0.06

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

Total # of neighbors = 116910
Ave neighs/atom = 58.455
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.110812094375, Press = -8.42949402791573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8404.0108     -8404.0108     -8490.2925     -8490.2925      333.91908      333.91908      23802.371      23802.371     -3030.3272     -3030.3272    
     12000  -8408.5074     -8408.5074     -8492.4204     -8492.4204      324.75224      324.75224      23755.357      23755.357     -161.20346     -161.20346    
Loop time of 98.5178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.366 hours/ns, 10.150 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.031     | 98.031     | 98.031     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073686   | 0.073686   | 0.073686   |   0.0 |  0.07
Output  | 0.00017157 | 0.00017157 | 0.00017157 |   0.0 |  0.00
Modify  | 0.35763    | 0.35763    | 0.35763    |   0.0 |  0.36
Other   |            | 0.05481    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116790 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395
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.803423165105, Press = 8.97283725078752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8408.5074     -8408.5074     -8492.4204     -8492.4204      324.75224      324.75224      23755.357      23755.357     -161.20346     -161.20346    
     13000  -8404.12       -8404.12       -8488.5906     -8488.5906      326.90978      326.90978      23742.675      23742.675      1447.3373      1447.3373    
Loop time of 98.5329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.370 hours/ns, 10.149 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.047     | 98.047     | 98.047     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073362   | 0.073362   | 0.073362   |   0.0 |  0.07
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35836    | 0.35836    | 0.35836    |   0.0 |  0.36
Other   |            | 0.05443    |            |       |  0.06

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

Total # of neighbors = 116842
Ave neighs/atom = 58.421
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.653344367097, Press = -1.73179694413804
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8404.12       -8404.12       -8488.5906     -8488.5906      326.90978      326.90978      23742.675      23742.675      1447.3373      1447.3373    
     14000  -8401.9263     -8401.9263     -8490.711      -8490.711       343.60609      343.60609      23776.697      23776.697     -1201.1108     -1201.1108    
Loop time of 98.6387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.400 hours/ns, 10.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.153     | 98.153     | 98.153     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073133   | 0.073133   | 0.073133   |   0.0 |  0.07
Output  | 0.00017052 | 0.00017052 | 0.00017052 |   0.0 |  0.00
Modify  | 0.35776    | 0.35776    | 0.35776    |   0.0 |  0.36
Other   |            | 0.05446    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116930 ave      116930 max      116930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116930
Ave neighs/atom = 58.465
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.715115377332, Press = -3.97503028772999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8401.9263     -8401.9263     -8490.711      -8490.711       343.60609      343.60609      23776.697      23776.697     -1201.1108     -1201.1108    
     15000  -8406.4963     -8406.4963     -8493.2863     -8493.2863      335.88655      335.88655      23770.821      23770.821     -1139.3751     -1139.3751    
Loop time of 98.6244 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.396 hours/ns, 10.139 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.139     | 98.139     | 98.139     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072872   | 0.072872   | 0.072872   |   0.0 |  0.07
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.35729    | 0.35729    | 0.35729    |   0.0 |  0.36
Other   |            | 0.0549     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116808 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404
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.566730511629, Press = 1.05202687591336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8406.4963     -8406.4963     -8493.2863     -8493.2863      335.88655      335.88655      23770.821      23770.821     -1139.3751     -1139.3751    
     16000  -8400.6861     -8400.6861     -8488.9115     -8488.9115      341.44114      341.44114      23722.388      23722.388      3080.8314      3080.8314    
Loop time of 98.6258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.396 hours/ns, 10.139 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.14      | 98.14      | 98.14      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073156   | 0.073156   | 0.073156   |   0.0 |  0.07
Output  | 0.00017053 | 0.00017053 | 0.00017053 |   0.0 |  0.00
Modify  | 0.35776    | 0.35776    | 0.35776    |   0.0 |  0.36
Other   |            | 0.05484    |            |       |  0.06

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

Total # of neighbors = 116790
Ave neighs/atom = 58.395
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.597738072717, Press = 5.07710526284324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8400.6861     -8400.6861     -8488.9115     -8488.9115      341.44114      341.44114      23722.388      23722.388      3080.8314      3080.8314    
     17000  -8402.071      -8402.071      -8488.2935     -8488.2935      333.69004      333.69004      23737.834      23737.834      1896.2221      1896.2221    
Loop time of 98.8112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.448 hours/ns, 10.120 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.326     | 98.326     | 98.326     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072901   | 0.072901   | 0.072901   |   0.0 |  0.07
Output  | 0.00016964 | 0.00016964 | 0.00016964 |   0.0 |  0.00
Modify  | 0.35736    | 0.35736    | 0.35736    |   0.0 |  0.36
Other   |            | 0.05489    |            |       |  0.06

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

Total # of neighbors = 116998
Ave neighs/atom = 58.499
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.6840974641, Press = -8.65715974662355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8402.071      -8402.071      -8488.2935     -8488.2935      333.69004      333.69004      23737.834      23737.834      1896.2221      1896.2221    
     18000  -8404.6874     -8404.6874     -8491.4062     -8491.4062      335.61084      335.61084      23793.627      23793.627     -2640.8894     -2640.8894    
Loop time of 98.8163 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.449 hours/ns, 10.120 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.331     | 98.331     | 98.331     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072726   | 0.072726   | 0.072726   |   0.0 |  0.07
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.35801    | 0.35801    | 0.35801    |   0.0 |  0.36
Other   |            | 0.05449    |            |       |  0.06

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

Total # of neighbors = 116914
Ave neighs/atom = 58.457
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.903053916427, Press = -2.31194996198508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8404.6874     -8404.6874     -8491.4062     -8491.4062      335.61084      335.61084      23793.627      23793.627     -2640.8894     -2640.8894    
     19000  -8399.128      -8399.128      -8486.7688     -8486.7688      339.17886      339.17886      23765.072      23765.072      244.79284      244.79284    
Loop time of 98.6626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.406 hours/ns, 10.136 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.177     | 98.177     | 98.177     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073323   | 0.073323   | 0.073323   |   0.0 |  0.07
Output  | 0.00016824 | 0.00016824 | 0.00016824 |   0.0 |  0.00
Modify  | 0.35786    | 0.35786    | 0.35786    |   0.0 |  0.36
Other   |            | 0.05459    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2956 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116802 ave      116802 max      116802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116802
Ave neighs/atom = 58.401
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.064135271085, Press = 4.01980669234838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8399.128      -8399.128      -8486.7688     -8486.7688      339.17886      339.17886      23765.072      23765.072      244.79284      244.79284    
     20000  -8403.7106     -8403.7106     -8491.3093     -8491.3093      339.0159       339.0159       23734.223      23734.223      1557.3505      1557.3505    
Loop time of 98.6917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.414 hours/ns, 10.133 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.205     | 98.205     | 98.205     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073359   | 0.073359   | 0.073359   |   0.0 |  0.07
Output  | 0.00016879 | 0.00016879 | 0.00016879 |   0.0 |  0.00
Modify  | 0.35775    | 0.35775    | 0.35775    |   0.0 |  0.36
Other   |            | 0.05504    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116876 ave      116876 max      116876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116876
Ave neighs/atom = 58.438
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.197412903871, Press = -1.10543234203039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8403.7106     -8403.7106     -8491.3093     -8491.3093      339.0159       339.0159       23734.223      23734.223      1557.3505      1557.3505    
     21000  -8404.8239     -8404.8239     -8489.5787     -8489.5787      328.00977      328.00977      23772.575      23772.575     -758.15077     -758.15077    
Loop time of 98.7943 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.443 hours/ns, 10.122 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.309     | 98.309     | 98.309     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073575   | 0.073575   | 0.073575   |   0.0 |  0.07
Output  | 0.00017039 | 0.00017039 | 0.00017039 |   0.0 |  0.00
Modify  | 0.35739    | 0.35739    | 0.35739    |   0.0 |  0.36
Other   |            | 0.05466    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116956 ave      116956 max      116956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116956
Ave neighs/atom = 58.478
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.152347724162, Press = -2.54779663529977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8404.8239     -8404.8239     -8489.5787     -8489.5787      328.00977      328.00977      23772.575      23772.575     -758.15077     -758.15077    
     22000  -8402.5985     -8402.5985     -8490.365      -8490.365       339.6655       339.6655       23778.576      23778.576     -1174.0083     -1174.0083    
Loop time of 98.4696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.353 hours/ns, 10.155 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.984     | 97.984     | 97.984     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073105   | 0.073105   | 0.073105   |   0.0 |  0.07
Output  | 0.00016983 | 0.00016983 | 0.00016983 |   0.0 |  0.00
Modify  | 0.35806    | 0.35806    | 0.35806    |   0.0 |  0.36
Other   |            | 0.05456    |            |       |  0.06

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

Total # of neighbors = 116888
Ave neighs/atom = 58.444
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.077101526651, Press = 2.12136783213957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8402.5985     -8402.5985     -8490.365      -8490.365       339.6655       339.6655       23778.576      23778.576     -1174.0083     -1174.0083    
     23000  -8407.1233     -8407.1233     -8492.7553     -8492.7553      331.40451      331.40451      23720.392      23720.392      2353.9575      2353.9575    
Loop time of 98.9013 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.473 hours/ns, 10.111 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.416     | 98.416     | 98.416     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072737   | 0.072737   | 0.072737   |   0.0 |  0.07
Output  | 0.00020223 | 0.00020223 | 0.00020223 |   0.0 |  0.00
Modify  | 0.35835    | 0.35835    | 0.35835    |   0.0 |  0.36
Other   |            | 0.05426    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2953 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116784 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392
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.957831789569, Press = 0.662581676571458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8407.1233     -8407.1233     -8492.7553     -8492.7553      331.40451      331.40451      23720.392      23720.392      2353.9575      2353.9575    
     24000  -8402.8037     -8402.8037     -8488.2051     -8488.2051      330.51247      330.51247      23769.997      23769.997     -384.98693     -384.98693    
Loop time of 98.5115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.364 hours/ns, 10.151 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.026     | 98.026     | 98.026     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073725   | 0.073725   | 0.073725   |   0.0 |  0.07
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.35741    | 0.35741    | 0.35741    |   0.0 |  0.36
Other   |            | 0.05464    |            |       |  0.06

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

Total # of neighbors = 116848
Ave neighs/atom = 58.424
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.920570183962, Press = -5.01284837751977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8402.8037     -8402.8037     -8488.2051     -8488.2051      330.51247      330.51247      23769.997      23769.997     -384.98693     -384.98693    
     25000  -8402.9566     -8402.9566     -8488.4693     -8488.4693      330.9427       330.9427       23798.359      23798.359     -2320.2681     -2320.2681    
Loop time of 98.8736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.465 hours/ns, 10.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.388     | 98.388     | 98.388     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073505   | 0.073505   | 0.073505   |   0.0 |  0.07
Output  | 0.00020475 | 0.00020475 | 0.00020475 |   0.0 |  0.00
Modify  | 0.35707    | 0.35707    | 0.35707    |   0.0 |  0.36
Other   |            | 0.05494    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2958 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116810 ave      116810 max      116810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116810
Ave neighs/atom = 58.405
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.928277692681, Press = 1.36085847920058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8402.9566     -8402.9566     -8488.4693     -8488.4693      330.9427       330.9427       23798.359      23798.359     -2320.2681     -2320.2681    
     26000  -8405.5239     -8405.5239     -8492.0391     -8492.0391      334.82269      334.82269      23736.42       23736.42       1359.9136      1359.9136    
Loop time of 98.6493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.403 hours/ns, 10.137 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.165     | 98.165     | 98.165     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072261   | 0.072261   | 0.072261   |   0.0 |  0.07
Output  | 0.0002041  | 0.0002041  | 0.0002041  |   0.0 |  0.00
Modify  | 0.35754    | 0.35754    | 0.35754    |   0.0 |  0.36
Other   |            | 0.05456    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2956 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116804 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402
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.090651253327, Press = 1.77496255763714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8405.5239     -8405.5239     -8492.0391     -8492.0391      334.82269      334.82269      23736.42       23736.42       1359.9136      1359.9136    
     27000  -8403.581      -8403.581      -8489.3666     -8489.3666      331.99922      331.99922      23745.134      23745.134      1165.8092      1165.8092    
Loop time of 98.7835 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.440 hours/ns, 10.123 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.298     | 98.298     | 98.298     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073836   | 0.073836   | 0.073836   |   0.0 |  0.07
Output  | 0.0002039  | 0.0002039  | 0.0002039  |   0.0 |  0.00
Modify  | 0.35742    | 0.35742    | 0.35742    |   0.0 |  0.36
Other   |            | 0.0545     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116856 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428
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.152259304331, Press = -1.64651104320825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8403.581      -8403.581      -8489.3666     -8489.3666      331.99922      331.99922      23745.134      23745.134      1165.8092      1165.8092    
     28000  -8406.1283     -8406.1283     -8489.6756     -8489.6756      323.33665      323.33665      23758.977      23758.977     -2.8318935     -2.8318935    
Loop time of 98.6395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.400 hours/ns, 10.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.154     | 98.154     | 98.154     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073704   | 0.073704   | 0.073704   |   0.0 |  0.07
Output  | 0.00020528 | 0.00020528 | 0.00020528 |   0.0 |  0.00
Modify  | 0.3573     | 0.3573     | 0.3573     |   0.0 |  0.36
Other   |            | 0.05461    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116950 ave      116950 max      116950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.877 ns/day, 27.375 hours/ns, 10.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.062     | 98.062     | 98.062     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073016   | 0.073016   | 0.073016   |   0.0 |  0.07
Output  | 0.00016997 | 0.00016997 | 0.00016997 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  0.36
Other   |            | 0.05521    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116916 ave      116916 max      116916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116916
Ave neighs/atom = 58.458
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.218002480355, Press = -0.621055059093185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8400.4649     -8400.4649     -8487.1265     -8487.1265      335.38928      335.38928      23761.555      23761.555      541.60623      541.60623    
     30000  -8404.5072     -8404.5072     -8491.5316     -8491.5316      336.79348      336.79348      23769.412      23769.412     -903.95419     -903.95419    
Loop time of 98.801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.445 hours/ns, 10.121 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.315     | 98.315     | 98.315     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073346   | 0.073346   | 0.073346   |   0.0 |  0.07
Output  | 0.00020028 | 0.00020028 | 0.00020028 |   0.0 |  0.00
Modify  | 0.35736    | 0.35736    | 0.35736    |   0.0 |  0.36
Other   |            | 0.05472    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116808 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404
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.323170942594, Press = -1.02656581401725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8404.5072     -8404.5072     -8491.5316     -8491.5316      336.79348      336.79348      23769.412      23769.412     -903.95419     -903.95419    
     31000  -8399.8158     -8399.8158     -8485.7363     -8485.7363      332.52136      332.52136      23794          23794         -1556.36       -1556.36      
Loop time of 98.7627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.434 hours/ns, 10.125 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.276     | 98.276     | 98.276     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072877   | 0.072877   | 0.072877   |   0.0 |  0.07
Output  | 0.0001687  | 0.0001687  | 0.0001687  |   0.0 |  0.00
Modify  | 0.3585     | 0.3585     | 0.3585     |   0.0 |  0.36
Other   |            | 0.05483    |            |       |  0.06

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

Total # of neighbors = 116852
Ave neighs/atom = 58.426
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.368114850843, Press = 1.06973527630848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8399.8158     -8399.8158     -8485.7363     -8485.7363      332.52136      332.52136      23794          23794         -1556.36       -1556.36      
     32000  -8404.0534     -8404.0534     -8491.8045     -8491.8045      339.60586      339.60586      23725.948      23725.948      2194.043       2194.043     
Loop time of 98.2959 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.304 hours/ns, 10.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.809     | 97.809     | 97.809     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073718   | 0.073718   | 0.073718   |   0.0 |  0.07
Output  | 0.00017112 | 0.00017112 | 0.00017112 |   0.0 |  0.00
Modify  | 0.35834    | 0.35834    | 0.35834    |   0.0 |  0.36
Other   |            | 0.05456    |            |       |  0.06

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

Total # of neighbors = 116804
Ave neighs/atom = 58.402
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.312819128286, Press = 1.76566807829897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8404.0534     -8404.0534     -8491.8045     -8491.8045      339.60586      339.60586      23725.948      23725.948      2194.043       2194.043     
     33000  -8402.8575     -8402.8575     -8488.7948     -8488.7948      332.58627      332.58627      23738.7        23738.7        1757.0391      1757.0391    
Loop time of 98.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.417 hours/ns, 10.132 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.213     | 98.213     | 98.213     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073447   | 0.073447   | 0.073447   |   0.0 |  0.07
Output  | 0.00017091 | 0.00017091 | 0.00017091 |   0.0 |  0.00
Modify  | 0.35825    | 0.35825    | 0.35825    |   0.0 |  0.36
Other   |            | 0.0547     |            |       |  0.06

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

Total # of neighbors = 116892
Ave neighs/atom = 58.446
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.247961610695, Press = -2.43222421705099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8402.8575     -8402.8575     -8488.7948     -8488.7948      332.58627      332.58627      23738.7        23738.7        1757.0391      1757.0391    
     34000  -8404.1981     -8404.1981     -8489.7843     -8489.7843      331.22743      331.22743      23781.148      23781.148     -1414.1586     -1414.1586    
Loop time of 98.5756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.382 hours/ns, 10.144 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.089     | 98.089     | 98.089     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073422   | 0.073422   | 0.073422   |   0.0 |  0.07
Output  | 0.00020832 | 0.00020832 | 0.00020832 |   0.0 |  0.00
Modify  | 0.35816    | 0.35816    | 0.35816    |   0.0 |  0.36
Other   |            | 0.0548     |            |       |  0.06

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

Total # of neighbors = 116952
Ave neighs/atom = 58.476
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.145939025914, Press = -1.74103572622085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8404.1981     -8404.1981     -8489.7843     -8489.7843      331.22743      331.22743      23781.148      23781.148     -1414.1586     -1414.1586    
     35000  -8406.1654     -8406.1654     -8491.4541     -8491.4541      330.07603      330.07603      23769.715      23769.715     -967.72694     -967.72694    
Loop time of 97.9615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.212 hours/ns, 10.208 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.479     | 97.479     | 97.479     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071796   | 0.071796   | 0.071796   |   0.0 |  0.07
Output  | 0.00016914 | 0.00016914 | 0.00016914 |   0.0 |  0.00
Modify  | 0.35613    | 0.35613    | 0.35613    |   0.0 |  0.36
Other   |            | 0.05473    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116800 ave      116800 max      116800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116800
Ave neighs/atom = 58.4
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.107364259283, Press = 0.72779226937211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8406.1654     -8406.1654     -8491.4541     -8491.4541      330.07603      330.07603      23769.715      23769.715     -967.72694     -967.72694    
     36000  -8401.3413     -8401.3413     -8488.8992     -8488.8992      338.8579       338.8579       23736.285      23736.285      2036.1749      2036.1749    
Loop time of 98.0766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.244 hours/ns, 10.196 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.592     | 97.592     | 97.592     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071965   | 0.071965   | 0.071965   |   0.0 |  0.07
Output  | 0.00017063 | 0.00017063 | 0.00017063 |   0.0 |  0.00
Modify  | 0.35652    | 0.35652    | 0.35652    |   0.0 |  0.36
Other   |            | 0.05551    |            |       |  0.06

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

Total # of neighbors = 116860
Ave neighs/atom = 58.43
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.173368109058, Press = -0.445104975263616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8401.3413     -8401.3413     -8488.8992     -8488.8992      338.8579       338.8579       23736.285      23736.285      2036.1749      2036.1749    
     37000  -8405.0409     -8405.0409     -8488.36       -8488.36        322.45359      322.45359      23771.219      23771.219     -604.60701     -604.60701    
Loop time of 98.0468 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.235 hours/ns, 10.199 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.562     | 97.562     | 97.562     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072815   | 0.072815   | 0.072815   |   0.0 |  0.07
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.35662    | 0.35662    | 0.35662    |   0.0 |  0.36
Other   |            | 0.05546    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116898 ave      116898 max      116898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116898
Ave neighs/atom = 58.449
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.233348561595, Press = -2.72012012682172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8405.0409     -8405.0409     -8488.36       -8488.36        322.45359      322.45359      23771.219      23771.219     -604.60701     -604.60701    
     38000  -8399.951      -8399.951      -8485.9897     -8485.9897      332.97846      332.97846      23818.753      23818.753     -3484.1477     -3484.1477    
Loop time of 97.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.214 hours/ns, 10.207 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.486     | 97.486     | 97.486     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072518   | 0.072518   | 0.072518   |   0.0 |  0.07
Output  | 0.00048865 | 0.00048865 | 0.00048865 |   0.0 |  0.00
Modify  | 0.35698    | 0.35698    | 0.35698    |   0.0 |  0.36
Other   |            | 0.05587    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2964 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116944 ave      116944 max      116944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116944
Ave neighs/atom = 58.472
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.323808539669, Press = 1.72499954803179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8399.951      -8399.951      -8485.9897     -8485.9897      332.97846      332.97846      23818.753      23818.753     -3484.1477     -3484.1477    
     39000  -8402.4727     -8402.4727     -8488.7587     -8488.7587      333.93563      333.93563      23733.753      23733.753      2098.5687      2098.5687    
Loop time of 98.1668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.269 hours/ns, 10.187 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.682     | 97.682     | 97.682     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072436   | 0.072436   | 0.072436   |   0.0 |  0.07
Output  | 0.00016816 | 0.00016816 | 0.00016816 |   0.0 |  0.00
Modify  | 0.35739    | 0.35739    | 0.35739    |   0.0 |  0.36
Other   |            | 0.05471    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2958 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116846 ave      116846 max      116846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116846
Ave neighs/atom = 58.423
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.340256655704, Press = 1.2131046548307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8402.4727     -8402.4727     -8488.7587     -8488.7587      333.93563      333.93563      23733.753      23733.753      2098.5687      2098.5687    
     40000  -8409.2227     -8409.2227     -8492.9581     -8492.9581      324.06458      324.06458      23736.009      23736.009      1290.8991      1290.8991    
Loop time of 110.268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.630 hours/ns, 9.069 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.71     | 109.71     | 109.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079478   | 0.079478   | 0.079478   |   0.0 |  0.07
Output  | 0.0002214  | 0.0002214  | 0.0002214  |   0.0 |  0.00
Modify  | 0.41986    | 0.41986    | 0.41986    |   0.0 |  0.38
Other   |            | 0.06129    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2959 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116942 ave      116942 max      116942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116942
Ave neighs/atom = 58.471
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.295569448958, Press = -1.88628752984218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8409.2227     -8409.2227     -8492.9581     -8492.9581      324.06458      324.06458      23736.009      23736.009      1290.8991      1290.8991    
     41000  -8402.7755     -8402.7755     -8489.9816     -8489.9816      337.49642      337.49642      23793.895      23793.895     -2300.5151     -2300.5151    
Loop time of 115.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.118 hours/ns, 8.649 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    | 115.04     | 115.04     | 115.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082851   | 0.082851   | 0.082851   |   0.0 |  0.07
Output  | 0.00016958 | 0.00016958 | 0.00016958 |   0.0 |  0.00
Modify  | 0.44392    | 0.44392    | 0.44392    |   0.0 |  0.38
Other   |            | 0.0634     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116838 ave      116838 max      116838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116838
Ave neighs/atom = 58.419
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.236011755524, Press = -0.526641261879355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8402.7755     -8402.7755     -8489.9816     -8489.9816      337.49642      337.49642      23793.895      23793.895     -2300.5151     -2300.5151    
     42000  -8404.3402     -8404.3402     -8490.4421     -8490.4421      333.22356      333.22356      23759.027      23759.027     -31.951628     -31.951628    
Loop time of 115.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.746 ns/day, 32.185 hours/ns, 8.631 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    | 115.27     | 115.27     | 115.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083082   | 0.083082   | 0.083082   |   0.0 |  0.07
Output  | 0.00016977 | 0.00016977 | 0.00016977 |   0.0 |  0.00
Modify  | 0.44556    | 0.44556    | 0.44556    |   0.0 |  0.38
Other   |            | 0.06335    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116856 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428
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.238962722794, Press = 1.07531666059152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8404.3402     -8404.3402     -8490.4421     -8490.4421      333.22356      333.22356      23759.027      23759.027     -31.951628     -31.951628    
     43000  -8404.4806     -8404.4806     -8490.2216     -8490.2216      331.82656      331.82656      23707.816      23707.816      3759.2389      3759.2389    
Loop time of 115.888 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.746 ns/day, 32.191 hours/ns, 8.629 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    | 115.3      | 115.3      | 115.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083756   | 0.083756   | 0.083756   |   0.0 |  0.07
Output  | 0.00021539 | 0.00021539 | 0.00021539 |   0.0 |  0.00
Modify  | 0.4451     | 0.4451     | 0.4451     |   0.0 |  0.38
Other   |            | 0.06308    |            |       |  0.05

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

Total # of neighbors = 116866
Ave neighs/atom = 58.433
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.184954546524, Press = -0.918362056293156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8404.4806     -8404.4806     -8490.2216     -8490.2216      331.82656      331.82656      23707.816      23707.816      3759.2389      3759.2389    
     44000  -8404.0833     -8404.0833     -8491.0819     -8491.0819      336.69353      336.69353      23799.182      23799.182     -2660.7895     -2660.7895    
Loop time of 116.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.744 ns/day, 32.249 hours/ns, 8.614 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    | 115.5      | 115.5      | 115.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083332   | 0.083332   | 0.083332   |   0.0 |  0.07
Output  | 0.0002152  | 0.0002152  | 0.0002152  |   0.0 |  0.00
Modify  | 0.44516    | 0.44516    | 0.44516    |   0.0 |  0.38
Other   |            | 0.06315    |            |       |  0.05

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

Total # of neighbors = 116918
Ave neighs/atom = 58.459
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.223900044087, Press = -3.60457184271936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8404.0833     -8404.0833     -8491.0819     -8491.0819      336.69353      336.69353      23799.182      23799.182     -2660.7895     -2660.7895    
     45000  -8401.1496     -8401.1496     -8487.8361     -8487.8361      335.48545      335.48545      23784.117      23784.117     -1182.8152     -1182.8152    
Loop time of 99.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.657 hours/ns, 10.044 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.071     | 99.071     | 99.071     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073423   | 0.073423   | 0.073423   |   0.0 |  0.07
Output  | 0.00016778 | 0.00016778 | 0.00016778 |   0.0 |  0.00
Modify  | 0.36486    | 0.36486    | 0.36486    |   0.0 |  0.37
Other   |            | 0.05608    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2964 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116750 ave      116750 max      116750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116750
Ave neighs/atom = 58.375
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.214408679394, Press = 0.653945235045892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8401.1496     -8401.1496     -8487.8361     -8487.8361      335.48545      335.48545      23784.117      23784.117     -1182.8152     -1182.8152    
     46000  -8404.9828     -8404.9828     -8489.5779     -8489.5779      327.39153      327.39153      23740.194      23740.194      1547.0408      1547.0408    
Loop time of 111.003 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.834 hours/ns, 9.009 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.44     | 110.44     | 110.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080932   | 0.080932   | 0.080932   |   0.0 |  0.07
Output  | 0.00017089 | 0.00017089 | 0.00017089 |   0.0 |  0.00
Modify  | 0.42238    | 0.42238    | 0.42238    |   0.0 |  0.38
Other   |            | 0.06198    |            |       |  0.06

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

Total # of neighbors = 116844
Ave neighs/atom = 58.422
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.281497981771, Press = 0.342558046518955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8404.9828     -8404.9828     -8489.5779     -8489.5779      327.39153      327.39153      23740.194      23740.194      1547.0408      1547.0408    
     47000  -8400.9206     -8400.9206     -8490.6119     -8490.6119      347.1144       347.1144       23765.082      23765.082     -371.24991     -371.24991    
Loop time of 115.61 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.114 hours/ns, 8.650 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    | 115.02     | 115.02     | 115.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083587   | 0.083587   | 0.083587   |   0.0 |  0.07
Output  | 0.00016539 | 0.00016539 | 0.00016539 |   0.0 |  0.00
Modify  | 0.44656    | 0.44656    | 0.44656    |   0.0 |  0.39
Other   |            | 0.06276    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116902 ave      116902 max      116902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116902
Ave neighs/atom = 58.451
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.301329951197, Press = -1.57744195484754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8400.9206     -8400.9206     -8490.6119     -8490.6119      347.1144       347.1144       23765.082      23765.082     -371.24991     -371.24991    
     48000  -8406.9613     -8406.9613     -8492.5113     -8492.5113      331.08755      331.08755      23799.735      23799.735     -3252.2566     -3252.2566    
Loop time of 114.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.832 hours/ns, 8.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.01     | 114.01     | 114.01     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082461   | 0.082461   | 0.082461   |   0.0 |  0.07
Output  | 0.00024583 | 0.00024583 | 0.00024583 |   0.0 |  0.00
Modify  | 0.44559    | 0.44559    | 0.44559    |   0.0 |  0.39
Other   |            | 0.06287    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116818 ave      116818 max      116818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116818
Ave neighs/atom = 58.409
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
23760.8713586083

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0