# 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 3.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.024436 33.024436 33.024436)
  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 (33.024436 33.024436 33.024436)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Ta__MO_644143102837_001
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36016.8901176252 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_644143102837_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -16114.588     -16114.588     -16180         -16180          253.15         253.15         36016.89       36016.89       1939.8334      1939.8334    
      1000  -16046.201     -16046.201     -16105.418     -16105.418      229.17525      229.17525      36226.703      36226.703     -2447.7134     -2447.7134    
Loop time of 98.2282 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.286 hours/ns, 10.180 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    | 97.731     | 97.731     | 97.731     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075162   | 0.075162   | 0.075162   |   0.0 |  0.08
Output  | 0.00024439 | 0.00024439 | 0.00024439 |   0.0 |  0.00
Modify  | 0.36489    | 0.36489    | 0.36489    |   0.0 |  0.37
Other   |            | 0.05685    |            |       |  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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -16046.201     -16046.201     -16105.418     -16105.418      229.17525      229.17525      36226.703      36226.703     -2447.7134     -2447.7134    
      2000  -16046.362     -16046.362     -16112.677     -16112.677      256.64482      256.64482      36138.723      36138.723      1510.2528      1510.2528    
Loop time of 99.9484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.763 hours/ns, 10.005 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    | 99.457     | 99.457     | 99.457     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074475   | 0.074475   | 0.074475   |   0.0 |  0.07
Output  | 0.00024323 | 0.00024323 | 0.00024323 |   0.0 |  0.00
Modify  | 0.35886    | 0.35886    | 0.35886    |   0.0 |  0.36
Other   |            | 0.05738    |            |       |  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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -16046.362     -16046.362     -16112.677     -16112.677      256.64482      256.64482      36138.723      36138.723      1510.2528      1510.2528    
      3000  -16047.667     -16047.667     -16115.414     -16115.414      262.1872       262.1872       36131.801      36131.801      1777.4219      1777.4219    
Loop time of 103.755 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.821 hours/ns, 9.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.24     | 103.24     | 103.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07692    | 0.07692    | 0.07692    |   0.0 |  0.07
Output  | 0.00020136 | 0.00020136 | 0.00020136 |   0.0 |  0.00
Modify  | 0.37704    | 0.37704    | 0.37704    |   0.0 |  0.36
Other   |            | 0.05868    |            |       |  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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -16047.667     -16047.667     -16115.414     -16115.414      262.1872       262.1872       36131.801      36131.801      1777.4219      1777.4219    
      4000  -16046.211     -16046.211     -16112.665     -16112.665      257.18473      257.18473      36223.385      36223.385     -2848.7105     -2848.7105    
Loop time of 101.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.112 hours/ns, 9.881 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    | 100.71     | 100.71     | 100.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075026   | 0.075026   | 0.075026   |   0.0 |  0.07
Output  | 0.00020199 | 0.00020199 | 0.00020199 |   0.0 |  0.00
Modify  | 0.36349    | 0.36349    | 0.36349    |   0.0 |  0.36
Other   |            | 0.05812    |            |       |  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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -16046.211     -16046.211     -16112.665     -16112.665      257.18473      257.18473      36223.385      36223.385     -2848.7105     -2848.7105    
      5000  -16047.824     -16047.824     -16117.934     -16117.934      271.33426      271.33426      36122.771      36122.771      2011.7103      2011.7103    
Loop time of 105.343 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.262 hours/ns, 9.493 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    | 104.82     | 104.82     | 104.82     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077196   | 0.077196   | 0.077196   |   0.0 |  0.07
Output  | 0.00016558 | 0.00016558 | 0.00016558 |   0.0 |  0.00
Modify  | 0.38797    | 0.38797    | 0.38797    |   0.0 |  0.37
Other   |            | 0.05915    |            |       |  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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
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 = 249.892939241638, Press = -305.711393592108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -16047.824     -16047.824     -16117.934     -16117.934      271.33426      271.33426      36122.771      36122.771      2011.7103      2011.7103    
      6000  -16048.577     -16048.577     -16116.365     -16116.365      262.34489      262.34489      36183.133      36183.133     -940.57852     -940.57852    
Loop time of 104.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.976 hours/ns, 9.586 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.78     | 103.78     | 103.78     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076933   | 0.076933   | 0.076933   |   0.0 |  0.07
Output  | 0.00016797 | 0.00016797 | 0.00016797 |   0.0 |  0.00
Modify  | 0.40224    | 0.40224    | 0.40224    |   0.0 |  0.39
Other   |            | 0.05814    |            |       |  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 = 252.087815453121, Press = -16.1717092766851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -16048.577     -16048.577     -16116.365     -16116.365      262.34489      262.34489      36183.133      36183.133     -940.57852     -940.57852    
      7000  -16048.091     -16048.091     -16112.724     -16112.724      250.13734      250.13734      36178.62       36178.62      -600.04878     -600.04878    
Loop time of 110.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.608 hours/ns, 9.075 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.62     | 109.62     | 109.62     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079622   | 0.079622   | 0.079622   |   0.0 |  0.07
Output  | 0.00021005 | 0.00021005 | 0.00021005 |   0.0 |  0.00
Modify  | 0.42887    | 0.42887    | 0.42887    |   0.0 |  0.39
Other   |            | 0.06029    |            |       |  0.05

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

Total # of neighbors = 115998
Ave neighs/atom = 57.999
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 = 252.072570250877, Press = -27.5614479475892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -16048.091     -16048.091     -16112.724     -16112.724      250.13734      250.13734      36178.62       36178.62      -600.04878     -600.04878    
      8000  -16048.984     -16048.984     -16115.009     -16115.009      255.52104      255.52104      36086.941      36086.941      3921.4065      3921.4065    
Loop time of 107.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.833 hours/ns, 9.311 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.84     | 106.84     | 106.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078525   | 0.078525   | 0.078525   |   0.0 |  0.07
Output  | 0.00016477 | 0.00016477 | 0.00016477 |   0.0 |  0.00
Modify  | 0.41749    | 0.41749    | 0.41749    |   0.0 |  0.39
Other   |            | 0.0599     |            |       |  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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
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 = 252.798117187951, Press = -10.3515177355845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -16048.984     -16048.984     -16115.009     -16115.009      255.52104      255.52104      36086.941      36086.941      3921.4065      3921.4065    
      9000  -16047.129     -16047.129     -16109.344     -16109.344      240.77839      240.77839      36200.997      36200.997     -1602.2196     -1602.2196    
Loop time of 106.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.690 hours/ns, 9.356 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.33     | 106.33     | 106.33     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078212   | 0.078212   | 0.078212   |   0.0 |  0.07
Output  | 0.00024879 | 0.00024879 | 0.00024879 |   0.0 |  0.00
Modify  | 0.41523    | 0.41523    | 0.41523    |   0.0 |  0.39
Other   |            | 0.05932    |            |       |  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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
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 = 252.552638373644, Press = -1.37047447325542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -16047.129     -16047.129     -16109.344     -16109.344      240.77839      240.77839      36200.997      36200.997     -1602.2196     -1602.2196    
     10000  -16047.568     -16047.568     -16114.471     -16114.471      258.91904      258.91904      36106.009      36106.009      3123.7442      3123.7442    
Loop time of 107.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.963 hours/ns, 9.271 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    | 107.31     | 107.31     | 107.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078093   | 0.078093   | 0.078093   |   0.0 |  0.07
Output  | 0.00016588 | 0.00016588 | 0.00016588 |   0.0 |  0.00
Modify  | 0.4151     | 0.4151     | 0.4151     |   0.0 |  0.38
Other   |            | 0.05939    |            |       |  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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
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 = 252.598458429654, Press = -7.12315160424784
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -16047.568     -16047.568     -16114.471     -16114.471      258.91904      258.91904      36106.009      36106.009      3123.7442      3123.7442    
     11000  -16051.333     -16051.333     -16112.499     -16112.499      236.71951      236.71951      36212.928      36212.928     -2468.1751     -2468.1751    
Loop time of 106.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.698 hours/ns, 9.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.36     | 106.36     | 106.36     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07826    | 0.07826    | 0.07826    |   0.0 |  0.07
Output  | 0.00016498 | 0.00016498 | 0.00016498 |   0.0 |  0.00
Modify  | 0.41748    | 0.41748    | 0.41748    |   0.0 |  0.39
Other   |            | 0.0597     |            |       |  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:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
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 = 252.745462632816, Press = -4.58334450904823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -16051.333     -16051.333     -16112.499     -16112.499      236.71951      236.71951      36212.928      36212.928     -2468.1751     -2468.1751    
     12000  -16048.875     -16048.875     -16114.542     -16114.542      254.13952      254.13952      36155.733      36155.733      451.63741      451.63741    
Loop time of 106.751 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.653 hours/ns, 9.368 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.2      | 106.2      | 106.2      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078425   | 0.078425   | 0.078425   |   0.0 |  0.07
Output  | 0.00025888 | 0.00025888 | 0.00025888 |   0.0 |  0.00
Modify  | 0.41374    | 0.41374    | 0.41374    |   0.0 |  0.39
Other   |            | 0.05886    |            |       |  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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
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 = 252.74146475553, Press = -5.88653397210158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -16048.875     -16048.875     -16114.542     -16114.542      254.13952      254.13952      36155.733      36155.733      451.63741      451.63741    
     13000  -16047.241     -16047.241     -16113.789     -16113.789      257.54835      257.54835      36166.055      36166.055     -21.00488      -21.00488     
Loop time of 105.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.183 hours/ns, 9.519 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    | 104.52     | 104.52     | 104.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076286   | 0.076286   | 0.076286   |   0.0 |  0.07
Output  | 0.00017048 | 0.00017048 | 0.00017048 |   0.0 |  0.00
Modify  | 0.40224    | 0.40224    | 0.40224    |   0.0 |  0.38
Other   |            | 0.05844    |            |       |  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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
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 = 252.706817581943, Press = -3.83103326101571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -16047.241     -16047.241     -16113.789     -16113.789      257.54835      257.54835      36166.055      36166.055     -21.00488      -21.00488     
     14000  -16048.142     -16048.142     -16115.136     -16115.136      259.27342      259.27342      36136.951      36136.951      1368.6338      1368.6338    
Loop time of 108.068 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.019 hours/ns, 9.253 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    | 107.51     | 107.51     | 107.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07912    | 0.07912    | 0.07912    |   0.0 |  0.07
Output  | 0.00043327 | 0.00043327 | 0.00043327 |   0.0 |  0.00
Modify  | 0.41855    | 0.41855    | 0.41855    |   0.0 |  0.39
Other   |            | 0.05926    |            |       |  0.05

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

Total # of neighbors = 115996
Ave neighs/atom = 57.998
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 = 252.682457156534, Press = -4.1696597557205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -16048.142     -16048.142     -16115.136     -16115.136      259.27342      259.27342      36136.951      36136.951      1368.6338      1368.6338    
     15000  -16047.587     -16047.587     -16116.694     -16116.694      267.45099      267.45099      36145.443      36145.443      867.51359      867.51359    
Loop time of 106.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.536 hours/ns, 9.405 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.78     | 105.78     | 105.78     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077836   | 0.077836   | 0.077836   |   0.0 |  0.07
Output  | 0.00026684 | 0.00026684 | 0.00026684 |   0.0 |  0.00
Modify  | 0.4131     | 0.4131     | 0.4131     |   0.0 |  0.39
Other   |            | 0.05911    |            |       |  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:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
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 = 252.764527965028, Press = -6.04726114879349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -16047.587     -16047.587     -16116.694     -16116.694      267.45099      267.45099      36145.443      36145.443      867.51359      867.51359    
     16000  -16047.453     -16047.453     -16112.721     -16112.721      252.59414      252.59414      36219.762      36219.762     -2710.6237     -2710.6237    
Loop time of 106.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.596 hours/ns, 9.386 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106        | 106        | 106        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077742   | 0.077742   | 0.077742   |   0.0 |  0.07
Output  | 0.00016577 | 0.00016577 | 0.00016577 |   0.0 |  0.00
Modify  | 0.40996    | 0.40996    | 0.40996    |   0.0 |  0.38
Other   |            | 0.05931    |            |       |  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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
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 = 252.755459558239, Press = -1.09626834985226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -16047.453     -16047.453     -16112.721     -16112.721      252.59414      252.59414      36219.762      36219.762     -2710.6237     -2710.6237    
     17000  -16048.477     -16048.477     -16111.356     -16111.356      243.34888      243.34888      36186.529      36186.529     -940.86568     -940.86568    
Loop time of 107.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.875 hours/ns, 9.298 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.99     | 106.99     | 106.99     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079107   | 0.079107   | 0.079107   |   0.0 |  0.07
Output  | 0.00016594 | 0.00016594 | 0.00016594 |   0.0 |  0.00
Modify  | 0.42135    | 0.42135    | 0.42135    |   0.0 |  0.39
Other   |            | 0.06016    |            |       |  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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
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 = 252.955853905085, Press = -0.307025668769902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -16048.477     -16048.477     -16111.356     -16111.356      243.34888      243.34888      36186.529      36186.529     -940.86568     -940.86568    
     18000  -16044.722     -16044.722     -16110.637     -16110.637      255.09714      255.09714      36120.607      36120.607      2628.7977      2628.7977    
Loop time of 104.841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.122 hours/ns, 9.538 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    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077119   | 0.077119   | 0.077119   |   0.0 |  0.07
Output  | 0.00016618 | 0.00016618 | 0.00016618 |   0.0 |  0.00
Modify  | 0.40151    | 0.40151    | 0.40151    |   0.0 |  0.38
Other   |            | 0.05881    |            |       |  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:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
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 = 253.008413385378, Press = -1.34690065477813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -16044.722     -16044.722     -16110.637     -16110.637      255.09714      255.09714      36120.607      36120.607      2628.7977      2628.7977    
     19000  -16049.545     -16049.545     -16114.966     -16114.966      253.18448      253.18448      36184.179      36184.179     -983.44888     -983.44888    
Loop time of 108.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.794 ns/day, 30.223 hours/ns, 9.191 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    | 108.24     | 108.24     | 108.24     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079575   | 0.079575   | 0.079575   |   0.0 |  0.07
Output  | 0.00021785 | 0.00021785 | 0.00021785 |   0.0 |  0.00
Modify  | 0.42226    | 0.42226    | 0.42226    |   0.0 |  0.39
Other   |            | 0.06018    |            |       |  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:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
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 = 253.122723548821, Press = -1.9863171093309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -16049.545     -16049.545     -16114.966     -16114.966      253.18448      253.18448      36184.179      36184.179     -983.44888     -983.44888    
     20000  -16047.675     -16047.675     -16113.364     -16113.364      254.22276      254.22276      36152.795      36152.795      804.11746      804.11746    
Loop time of 106.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.617 hours/ns, 9.379 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.07     | 106.07     | 106.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078223   | 0.078223   | 0.078223   |   0.0 |  0.07
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.4119     | 0.4119     | 0.4119     |   0.0 |  0.39
Other   |            | 0.05941    |            |       |  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:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
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 = 253.135042141623, Press = -3.47320132473242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -16047.675     -16047.675     -16113.364     -16113.364      254.22276      254.22276      36152.795      36152.795      804.11746      804.11746    
     21000  -16048.266     -16048.266     -16114.425     -16114.425      256.04199      256.04199      36179.995      36179.995     -787.82396     -787.82396    
Loop time of 109.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.351 hours/ns, 9.152 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    | 108.7      | 108.7      | 108.7      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079441   | 0.079441   | 0.079441   |   0.0 |  0.07
Output  | 0.00017003 | 0.00017003 | 0.00017003 |   0.0 |  0.00
Modify  | 0.42448    | 0.42448    | 0.42448    |   0.0 |  0.39
Other   |            | 0.05987    |            |       |  0.05

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

Total # of neighbors = 115992
Ave neighs/atom = 57.996
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 = 253.067402099779, Press = -3.67736838318525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -16048.266     -16048.266     -16114.425     -16114.425      256.04199      256.04199      36179.995      36179.995     -787.82396     -787.82396    
     22000  -16046.129     -16046.129     -16114.752     -16114.752      265.57637      265.57637      36181.232      36181.232     -648.56351     -648.56351    
Loop time of 107.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.922 hours/ns, 9.283 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    | 107.16     | 107.16     | 107.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078481   | 0.078481   | 0.078481   |   0.0 |  0.07
Output  | 0.00019154 | 0.00019154 | 0.00019154 |   0.0 |  0.00
Modify  | 0.41847    | 0.41847    | 0.41847    |   0.0 |  0.39
Other   |            | 0.06036    |            |       |  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:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
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 = 253.165520375919, Press = 1.28211137091868
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -16046.129     -16046.129     -16114.752     -16114.752      265.57637      265.57637      36181.232      36181.232     -648.56351     -648.56351    
     23000  -16048.55      -16048.55      -16112.789     -16112.789      248.61196      248.61196      36152.554      36152.554      810.21234      810.21234    
Loop time of 107.023 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.729 hours/ns, 9.344 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.47     | 106.47     | 106.47     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078351   | 0.078351   | 0.078351   |   0.0 |  0.07
Output  | 0.00016508 | 0.00016508 | 0.00016508 |   0.0 |  0.00
Modify  | 0.41408    | 0.41408    | 0.41408    |   0.0 |  0.39
Other   |            | 0.05935    |            |       |  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 = 253.147086925235, Press = -1.72463166603015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -16048.55      -16048.55      -16112.789     -16112.789      248.61196      248.61196      36152.554      36152.554      810.21234      810.21234    
     24000  -16047.538     -16047.538     -16112.513     -16112.513      251.46328      251.46328      36182.08       36182.08      -794.34563     -794.34563    
Loop time of 107.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.835 hours/ns, 9.311 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.85     | 106.85     | 106.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078632   | 0.078632   | 0.078632   |   0.0 |  0.07
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.41596    | 0.41596    | 0.41596    |   0.0 |  0.39
Other   |            | 0.0593     |            |       |  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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
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 = 253.250215770487, Press = -2.24089516454034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -16047.538     -16047.538     -16112.513     -16112.513      251.46328      251.46328      36182.08       36182.08      -794.34563     -794.34563    
     25000  -16048.067     -16048.067     -16112.381     -16112.381      248.90348      248.90348      36205.194      36205.194     -1944.2718     -1944.2718    
Loop time of 104.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.003 hours/ns, 9.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.88     | 103.88     | 103.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076451   | 0.076451   | 0.076451   |   0.0 |  0.07
Output  | 0.00021099 | 0.00021099 | 0.00021099 |   0.0 |  0.00
Modify  | 0.39808    | 0.39808    | 0.39808    |   0.0 |  0.38
Other   |            | 0.05827    |            |       |  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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
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 = 253.320934976614, Press = -0.748375069209844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -16048.067     -16048.067     -16112.381     -16112.381      248.90348      248.90348      36205.194      36205.194     -1944.2718     -1944.2718    
     26000  -16047.473     -16047.473     -16115.637     -16115.637      263.79983      263.79983      36111.149      36111.149      2874.6061      2874.6061    
Loop time of 107.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.746 hours/ns, 9.338 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.53     | 106.53     | 106.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078965   | 0.078965   | 0.078965   |   0.0 |  0.07
Output  | 0.00020685 | 0.00020685 | 0.00020685 |   0.0 |  0.00
Modify  | 0.41626    | 0.41626    | 0.41626    |   0.0 |  0.39
Other   |            | 0.05983    |            |       |  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 = 253.270836911941, Press = -1.6705394824639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -16047.473     -16047.473     -16115.637     -16115.637      263.79983      263.79983      36111.149      36111.149      2874.6061      2874.6061    
     27000  -16047.542     -16047.542     -16112.65      -16112.65       251.97329      251.97329      36176.965      36176.965     -399.69816     -399.69816    
Loop time of 107.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.898 hours/ns, 9.291 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    | 107.08     | 107.08     | 107.08     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078786   | 0.078786   | 0.078786   |   0.0 |  0.07
Output  | 0.00021265 | 0.00021265 | 0.00021265 |   0.0 |  0.00
Modify  | 0.41887    | 0.41887    | 0.41887    |   0.0 |  0.39
Other   |            | 0.05968    |            |       |  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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
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 = 253.250735217275, Press = -1.07142873403462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -16047.542     -16047.542     -16112.65      -16112.65       251.97329      251.97329      36176.965      36176.965     -399.69816     -399.69816    
     28000  -16045.608     -16045.608     -16112.424     -16112.424      258.58822      258.58822      36180.459      36180.459     -520.31776     -520.31776    
Loop time of 107.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.941 hours/ns, 9.277 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    | 107.23     | 107.23     | 107.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079139   | 0.079139   | 0.079139   |   0.0 |  0.07
Output  | 0.00016526 | 0.00016526 | 0.00016526 |   0.0 |  0.00
Modify  | 0.41924    | 0.41924    | 0.41924    |   0.0 |  0.39
Other   |            | 0.06006    |            |       |  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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
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 = 253.31920278336, Press = -2.09294671683501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -16045.608     -16045.608     -16112.424     -16112.424      258.58822      258.58822      36180.459      36180.459     -520.31776     -520.31776    
     29000  -16047.654     -16047.654     -16113.776     -16113.776      255.89807      255.89807      36188.169      36188.169     -1127.6734     -1127.6734    
Loop time of 107.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.798 hours/ns, 9.322 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.72     | 106.72     | 106.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077775   | 0.077775   | 0.077775   |   0.0 |  0.07
Output  | 0.00016489 | 0.00016489 | 0.00016489 |   0.0 |  0.00
Modify  | 0.41115    | 0.41115    | 0.41115    |   0.0 |  0.38
Other   |            | 0.05999    |            |       |  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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
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 = 253.269253527609, Press = -1.4973778956957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -16047.654     -16047.654     -16113.776     -16113.776      255.89807      255.89807      36188.169      36188.169     -1127.6734     -1127.6734    
     30000  -16051.079     -16051.079     -16114.487     -16114.487      245.39545      245.39545      36126.74       36126.74       1921.7967      1921.7967    
Loop time of 104.396 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.999 hours/ns, 9.579 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076976   | 0.076976   | 0.076976   |   0.0 |  0.07
Output  | 0.00016752 | 0.00016752 | 0.00016752 |   0.0 |  0.00
Modify  | 0.40052    | 0.40052    | 0.40052    |   0.0 |  0.38
Other   |            | 0.05861    |            |       |  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:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
36167.0620151902

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0