# 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 4.049985826015473*${_u_distance}
variable latticeconst_converted equal 4.049985826015473*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04998582601547
Lattice spacing in x,y,z = 4.0499858 4.0499858 4.0499858
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.499858 40.499858 40.499858)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.499858 40.499858 40.499858)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_SunRamachandranWick_2018_TiAl__MO_022920256108_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  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) = 4.143 | 4.143 | 4.143 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13250.675     -13250.675     -13412.545     -13412.545      313.15         313.15         66429.428      66429.428      2602.7049      2602.7049    
      1000  -13072.733     -13072.733     -13237.93      -13237.93       319.58596      319.58596      67559.489      67559.489     -500.75387     -500.75387    
Loop time of 40.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.135 ns/day, 11.243 hours/ns, 24.706 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    | 40.333     | 40.333     | 40.333     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014952   | 0.014952   | 0.014952   |   0.0 |  0.04
Output  | 0.00019122 | 0.00019122 | 0.00019122 |   0.0 |  0.00
Modify  | 0.11808    | 0.11808    | 0.11808    |   0.0 |  0.29
Other   |            | 0.009658   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 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:       216000 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13072.733     -13072.733     -13237.93      -13237.93       319.58596      319.58596      67559.489      67559.489     -500.75387     -500.75387    
      2000  -13088.355     -13088.355     -13246.758     -13246.758      306.44079      306.44079      67478.955      67478.955     -267.70877     -267.70877    
Loop time of 45.1279 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.915 ns/day, 12.536 hours/ns, 22.159 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    | 44.975     | 44.975     | 44.975     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017962   | 0.017962   | 0.017962   |   0.0 |  0.04
Output  | 0.00015824 | 0.00015824 | 0.00015824 |   0.0 |  0.00
Modify  | 0.11942    | 0.11942    | 0.11942    |   0.0 |  0.26
Other   |            | 0.01486    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4068 ave        4068 max        4068 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:       214472 ave      214472 max      214472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214472
Ave neighs/atom = 53.618
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13088.355     -13088.355     -13246.758     -13246.758      306.44079      306.44079      67478.955      67478.955     -267.70877     -267.70877    
      3000  -13081.364     -13081.364     -13241.725     -13241.725      310.22911      310.22911      67434.618      67434.618      397.50392      397.50392    
Loop time of 45.4271 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.902 ns/day, 12.619 hours/ns, 22.013 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    | 45.271     | 45.271     | 45.271     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018775   | 0.018775   | 0.018775   |   0.0 |  0.04
Output  | 7.0953e-05 | 7.0953e-05 | 7.0953e-05 |   0.0 |  0.00
Modify  | 0.1203     | 0.1203     | 0.1203     |   0.0 |  0.26
Other   |            | 0.01688    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4039 ave        4039 max        4039 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:       214790 ave      214790 max      214790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214790
Ave neighs/atom = 53.6975
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13081.364     -13081.364     -13241.725     -13241.725      310.22911      310.22911      67434.618      67434.618      397.50392      397.50392    
      4000  -13082.961     -13082.961     -13245.111     -13245.111      313.69073      313.69073      67479.68       67479.68      -141.59734     -141.59734    
Loop time of 45.4775 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.633 hours/ns, 21.989 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    | 45.321     | 45.321     | 45.321     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019045   | 0.019045   | 0.019045   |   0.0 |  0.04
Output  | 6.9751e-05 | 6.9751e-05 | 6.9751e-05 |   0.0 |  0.00
Modify  | 0.12021    | 0.12021    | 0.12021    |   0.0 |  0.26
Other   |            | 0.0173     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4085 ave        4085 max        4085 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:       214764 ave      214764 max      214764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214764
Ave neighs/atom = 53.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13082.961     -13082.961     -13245.111     -13245.111      313.69073      313.69073      67479.68       67479.68      -141.59734     -141.59734    
      5000  -13084.955     -13084.955     -13238.811     -13238.811      297.64576      297.64576      67506.688      67506.688     -245.84897     -245.84897    
Loop time of 45.4015 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.903 ns/day, 12.612 hours/ns, 22.026 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    | 45.238     | 45.238     | 45.238     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020438   | 0.020438   | 0.020438   |   0.0 |  0.05
Output  | 4.9302e-05 | 4.9302e-05 | 4.9302e-05 |   0.0 |  0.00
Modify  | 0.12235    | 0.12235    | 0.12235    |   0.0 |  0.27
Other   |            | 0.02057    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4026 ave        4026 max        4026 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:       214670 ave      214670 max      214670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214670
Ave neighs/atom = 53.6675
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 = 311.7524045828, Press = -293.833288454195
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13084.955     -13084.955     -13238.811     -13238.811      297.64576      297.64576      67506.688      67506.688     -245.84897     -245.84897    
      6000  -13082.13      -13082.13      -13244.798     -13244.798      314.69137      314.69137      67373.747      67373.747      866.40558      866.40558    
Loop time of 45.4654 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.629 hours/ns, 21.995 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    | 45.309     | 45.309     | 45.309     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018174   | 0.018174   | 0.018174   |   0.0 |  0.04
Output  | 4.3051e-05 | 4.3051e-05 | 4.3051e-05 |   0.0 |  0.00
Modify  | 0.12291    | 0.12291    | 0.12291    |   0.0 |  0.27
Other   |            | 0.01518    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4093 ave        4093 max        4093 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:       214578 ave      214578 max      214578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214578
Ave neighs/atom = 53.6445
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 = 312.626340443452, Press = -30.9211724557425
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13082.13      -13082.13      -13244.798     -13244.798      314.69137      314.69137      67373.747      67373.747      866.40558      866.40558    
      7000  -13083.991     -13083.991     -13245.444     -13245.444      312.34158      312.34158      67443.449      67443.449      228.7705       228.7705     
Loop time of 45.4335 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.902 ns/day, 12.620 hours/ns, 22.010 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    | 45.284     | 45.284     | 45.284     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016697   | 0.016697   | 0.016697   |   0.0 |  0.04
Output  | 3.1349e-05 | 3.1349e-05 | 3.1349e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.27
Other   |            | 0.0117     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4059 ave        4059 max        4059 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:       214866 ave      214866 max      214866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214866
Ave neighs/atom = 53.7165
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 = 313.123240719442, Press = 17.5687489653157
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13083.991     -13083.991     -13245.444     -13245.444      312.34158      312.34158      67443.449      67443.449      228.7705       228.7705     
      8000  -13081.716     -13081.716     -13244.973     -13244.973      315.83223      315.83223      67571.102      67571.102     -938.36259     -938.36259    
Loop time of 45.3075 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.907 ns/day, 12.585 hours/ns, 22.071 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    | 45.154     | 45.154     | 45.154     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017275   | 0.017275   | 0.017275   |   0.0 |  0.04
Output  | 4.1848e-05 | 4.1848e-05 | 4.1848e-05 |   0.0 |  0.00
Modify  | 0.12223    | 0.12223    | 0.12223    |   0.0 |  0.27
Other   |            | 0.01382    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4064 ave        4064 max        4064 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:       214726 ave      214726 max      214726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214726
Ave neighs/atom = 53.6815
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 = 312.722287718225, Press = -7.14535479035452
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13081.716     -13081.716     -13244.973     -13244.973      315.83223      315.83223      67571.102      67571.102     -938.36259     -938.36259    
      9000  -13089.184     -13089.184     -13248.377     -13248.377      307.9696       307.9696       67407.155      67407.155      336.88738      336.88738    
Loop time of 45.5345 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.897 ns/day, 12.648 hours/ns, 21.961 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    | 45.38      | 45.38      | 45.38      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017691   | 0.017691   | 0.017691   |   0.0 |  0.04
Output  | 5.0525e-05 | 5.0525e-05 | 5.0525e-05 |   0.0 |  0.00
Modify  | 0.12247    | 0.12247    | 0.12247    |   0.0 |  0.27
Other   |            | 0.01434    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4074 ave        4074 max        4074 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:       214658 ave      214658 max      214658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214658
Ave neighs/atom = 53.6645
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 = 312.5589724399, Press = -6.85191788262843
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13089.184     -13089.184     -13248.377     -13248.377      307.9696       307.9696       67407.155      67407.155      336.88738      336.88738    
     10000  -13082.47      -13082.47      -13246.093     -13246.093      316.54064      316.54064      67442.851      67442.851      181.25826      181.25826    
Loop time of 45.3674 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.602 hours/ns, 22.042 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    | 45.212     | 45.212     | 45.212     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017801   | 0.017801   | 0.017801   |   0.0 |  0.04
Output  | 3.8413e-05 | 3.8413e-05 | 3.8413e-05 |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.27
Other   |            | 0.01516    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4054 ave        4054 max        4054 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:       214820 ave      214820 max      214820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214820
Ave neighs/atom = 53.705
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 = 312.490024201213, Press = 0.223724077863876
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13082.47      -13082.47      -13246.093     -13246.093      316.54064      316.54064      67442.851      67442.851      181.25826      181.25826    
     11000  -13091.109     -13091.109     -13249.506     -13249.506      306.42903      306.42903      67495.127      67495.127     -532.88515     -532.88515    
Loop time of 45.4694 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.630 hours/ns, 21.993 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    | 45.315     | 45.315     | 45.315     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017819   | 0.017819   | 0.017819   |   0.0 |  0.04
Output  | 2.9035e-05 | 2.9035e-05 | 2.9035e-05 |   0.0 |  0.00
Modify  | 0.12244    | 0.12244    | 0.12244    |   0.0 |  0.27
Other   |            | 0.0144     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4120 ave        4120 max        4120 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:       214782 ave      214782 max      214782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214782
Ave neighs/atom = 53.6955
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 = 312.221593092349, Press = -2.37117346811899
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13091.109     -13091.109     -13249.506     -13249.506      306.42903      306.42903      67495.127      67495.127     -532.88515     -532.88515    
     12000  -13083.294     -13083.294     -13244.873     -13244.873      312.58563      312.58563      67425.945      67425.945      390.83446      390.83446    
Loop time of 45.3878 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.608 hours/ns, 22.032 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    | 45.235     | 45.235     | 45.235     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016999   | 0.016999   | 0.016999   |   0.0 |  0.04
Output  | 4.241e-05  | 4.241e-05  | 4.241e-05  |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.27
Other   |            | 0.01363    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4012 ave        4012 max        4012 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:       214762 ave      214762 max      214762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214762
Ave neighs/atom = 53.6905
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 = 312.272459127041, Press = -4.83118589980268
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13083.294     -13083.294     -13244.873     -13244.873      312.58563      312.58563      67425.945      67425.945      390.83446      390.83446    
     13000  -13076.059     -13076.059     -13239.788     -13239.788      316.74484      316.74484      67432.563      67432.563      526.12984      526.12984    
Loop time of 45.3973 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.903 ns/day, 12.610 hours/ns, 22.028 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    | 45.238     | 45.238     | 45.238     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01873    | 0.01873    | 0.01873    |   0.0 |  0.04
Output  | 4.1699e-05 | 4.1699e-05 | 4.1699e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.27
Other   |            | 0.01673    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4077 ave        4077 max        4077 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:       214736 ave      214736 max      214736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214736
Ave neighs/atom = 53.684
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 = 312.400289134197, Press = 1.72745334135208
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13076.059     -13076.059     -13239.788     -13239.788      316.74484      316.74484      67432.563      67432.563      526.12984      526.12984    
     14000  -13085.212     -13085.212     -13246.16      -13246.16       311.36407      311.36407      67579.545      67579.545     -1109.0701     -1109.0701    
Loop time of 45.5171 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.898 ns/day, 12.644 hours/ns, 21.970 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    | 45.356     | 45.356     | 45.356     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019373   | 0.019373   | 0.019373   |   0.0 |  0.04
Output  | 7.0993e-05 | 7.0993e-05 | 7.0993e-05 |   0.0 |  0.00
Modify  | 0.12402    | 0.12402    | 0.12402    |   0.0 |  0.27
Other   |            | 0.01789    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4065 ave        4065 max        4065 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:       214658 ave      214658 max      214658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214658
Ave neighs/atom = 53.6645
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 = 312.677820629977, Press = -1.3331717067238
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13085.212     -13085.212     -13246.16      -13246.16       311.36407      311.36407      67579.545      67579.545     -1109.0701     -1109.0701    
     15000  -13078.72      -13078.72      -13242.092     -13242.092      316.05432      316.05432      67465.277      67465.277      168.07152      168.07152    
Loop time of 45.5001 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.899 ns/day, 12.639 hours/ns, 21.978 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    | 45.341     | 45.341     | 45.341     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018784   | 0.018784   | 0.018784   |   0.0 |  0.04
Output  | 3.0448e-05 | 3.0448e-05 | 3.0448e-05 |   0.0 |  0.00
Modify  | 0.12356    | 0.12356    | 0.12356    |   0.0 |  0.27
Other   |            | 0.01683    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4069 ave        4069 max        4069 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:       214772 ave      214772 max      214772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214772
Ave neighs/atom = 53.693
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 = 312.847071718938, Press = -5.19232288616178
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13078.72      -13078.72      -13242.092     -13242.092      316.05432      316.05432      67465.277      67465.277      168.07152      168.07152    
     16000  -13083.39      -13083.39      -13245.666     -13245.666      313.93303      313.93303      67425.915      67425.915      345.09504      345.09504    
Loop time of 45.4665 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.630 hours/ns, 21.994 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    | 45.306     | 45.306     | 45.306     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019053   | 0.019053   | 0.019053   |   0.0 |  0.04
Output  | 6.5533e-05 | 6.5533e-05 | 6.5533e-05 |   0.0 |  0.00
Modify  | 0.12409    | 0.12409    | 0.12409    |   0.0 |  0.27
Other   |            | 0.01736    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4069 ave        4069 max        4069 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:       214696 ave      214696 max      214696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214696
Ave neighs/atom = 53.674
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 = 312.78097086539, Press = -0.569232831540483
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13083.39      -13083.39      -13245.666     -13245.666      313.93303      313.93303      67425.915      67425.915      345.09504      345.09504    
     17000  -13082.112     -13082.112     -13244.403     -13244.403      313.96402      313.96402      67504.17       67504.17      -327.44126     -327.44126    
Loop time of 45.2891 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.908 ns/day, 12.580 hours/ns, 22.080 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    | 45.133     | 45.133     | 45.133     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017842   | 0.017842   | 0.017842   |   0.0 |  0.04
Output  | 4.254e-05  | 4.254e-05  | 4.254e-05  |   0.0 |  0.00
Modify  | 0.1228     | 0.1228     | 0.1228     |   0.0 |  0.27
Other   |            | 0.01513    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4046 ave        4046 max        4046 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:       214834 ave      214834 max      214834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214834
Ave neighs/atom = 53.7085
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 = 312.752681486442, Press = -0.858912529498765
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13082.112     -13082.112     -13244.403     -13244.403      313.96402      313.96402      67504.17       67504.17      -327.44126     -327.44126    
     18000  -13083.412     -13083.412     -13243.688     -13243.688      310.06451      310.06451      67464.811      67464.811     -3.3066794     -3.3066794    
Loop time of 45.3889 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.608 hours/ns, 22.032 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    | 45.232     | 45.232     | 45.232     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018297   | 0.018297   | 0.018297   |   0.0 |  0.04
Output  | 3.726e-05  | 3.726e-05  | 3.726e-05  |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.27
Other   |            | 0.01586    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4047 ave        4047 max        4047 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:       214704 ave      214704 max      214704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214704
Ave neighs/atom = 53.676
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 = 312.74245576097, Press = -2.40471663823334
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13083.412     -13083.412     -13243.688     -13243.688      310.06451      310.06451      67464.811      67464.811     -3.3066794     -3.3066794    
     19000  -13089.858     -13089.858     -13248.361     -13248.361      306.63484      306.63484      67368.665      67368.665      739.96911      739.96911    
Loop time of 45.3725 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.603 hours/ns, 22.040 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    | 45.215     | 45.215     | 45.215     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018408   | 0.018408   | 0.018408   |   0.0 |  0.04
Output  | 3.172e-05  | 3.172e-05  | 3.172e-05  |   0.0 |  0.00
Modify  | 0.12299    | 0.12299    | 0.12299    |   0.0 |  0.27
Other   |            | 0.01611    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4060 ave        4060 max        4060 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:       214776 ave      214776 max      214776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214776
Ave neighs/atom = 53.694
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 = 312.700821074212, Press = -0.504760303647226
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13089.858     -13089.858     -13248.361     -13248.361      306.63484      306.63484      67368.665      67368.665      739.96911      739.96911    
     20000  -13080.305     -13080.305     -13239.934     -13239.934      308.8123       308.8123       67582.319      67582.319     -881.59813     -881.59813    
Loop time of 45.2129 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.911 ns/day, 12.559 hours/ns, 22.118 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    | 45.058     | 45.058     | 45.058     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017597   | 0.017597   | 0.017597   |   0.0 |  0.04
Output  | 4.0667e-05 | 4.0667e-05 | 4.0667e-05 |   0.0 |  0.00
Modify  | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.27
Other   |            | 0.01436    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4073 ave        4073 max        4073 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:       214880 ave      214880 max      214880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214880
Ave neighs/atom = 53.72
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.64747181369, Press = 0.854149986560974
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13080.305     -13080.305     -13239.934     -13239.934      308.8123       308.8123       67582.319      67582.319     -881.59813     -881.59813    
     21000  -13083.529     -13083.529     -13246.626     -13246.626      315.52298      315.52298      67501.591      67501.591     -368.87599     -368.87599    
Loop time of 45.3779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.605 hours/ns, 22.037 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    | 45.221     | 45.221     | 45.221     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.018226   | 0.018226   | 0.018226   |   0.0 |  0.04
Output  | 4.228e-05  | 4.228e-05  | 4.228e-05  |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.27
Other   |            | 0.01541    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       214596 ave      214596 max      214596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214596
Ave neighs/atom = 53.649
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 = 312.694881986643, Press = -3.40434843193113
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13083.529     -13083.529     -13246.626     -13246.626      315.52298      315.52298      67501.591      67501.591     -368.87599     -368.87599    
     22000  -13083.295     -13083.295     -13244.824     -13244.824      312.48773      312.48773      67398.896      67398.896      627.11084      627.11084    
Loop time of 45.4258 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.902 ns/day, 12.618 hours/ns, 22.014 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    | 45.27      | 45.27      | 45.27      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017832   | 0.017832   | 0.017832   |   0.0 |  0.04
Output  | 4.3952e-05 | 4.3952e-05 | 4.3952e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.27
Other   |            | 0.01532    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4022 ave        4022 max        4022 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:       214768 ave      214768 max      214768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214768
Ave neighs/atom = 53.692
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 = 312.742528173297, Press = -0.638934994693711
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13083.295     -13083.295     -13244.824     -13244.824      312.48773      312.48773      67398.896      67398.896      627.11084      627.11084    
     23000  -13083.98      -13083.98      -13247.196     -13247.196      315.75239      315.75239      67483.094      67483.094     -213.66033     -213.66033    
Loop time of 45.4816 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.634 hours/ns, 21.987 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.329     | 45.329     | 45.329     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017096   | 0.017096   | 0.017096   |   0.0 |  0.04
Output  | 3.2672e-05 | 3.2672e-05 | 3.2672e-05 |   0.0 |  0.00
Modify  | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.27
Other   |            | 0.01323    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4075 ave        4075 max        4075 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:       214794 ave      214794 max      214794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214794
Ave neighs/atom = 53.6985
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 = 312.664222881837, Press = 0.0339189342097113
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13083.98      -13083.98      -13247.196     -13247.196      315.75239      315.75239      67483.094      67483.094     -213.66033     -213.66033    
     24000  -13085.432     -13085.432     -13248.155     -13248.155      314.79841      314.79841      67477.072      67477.072     -244.40508     -244.40508    
Loop time of 45.7611 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.888 ns/day, 12.711 hours/ns, 21.853 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.604     | 45.604     | 45.604     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.017878   | 0.017878   | 0.017878   |   0.0 |  0.04
Output  | 4.3271e-05 | 4.3271e-05 | 4.3271e-05 |   0.0 |  0.00
Modify  | 0.12434    | 0.12434    | 0.12434    |   0.0 |  0.27
Other   |            | 0.0152     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4003 ave        4003 max        4003 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:       214844 ave      214844 max      214844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214844
Ave neighs/atom = 53.711
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 = 312.706166731797, Press = -1.27537459626782
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13085.432     -13085.432     -13248.155     -13248.155      314.79841      314.79841      67477.072      67477.072     -244.40508     -244.40508    
     25000  -13081.488     -13081.488     -13241.786     -13241.786      310.10728      310.10728      67457.811      67457.811      150.85728      150.85728    
Loop time of 45.7192 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.890 ns/day, 12.700 hours/ns, 21.873 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.552     | 45.552     | 45.552     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0204     | 0.0204     | 0.0204     |   0.0 |  0.04
Output  | 4.264e-05  | 4.264e-05  | 4.264e-05  |   0.0 |  0.00
Modify  | 0.1265     | 0.1265     | 0.1265     |   0.0 |  0.28
Other   |            | 0.01998    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4068 ave        4068 max        4068 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:       214738 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.6845
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 = 312.684974448197, Press = -0.990733473215337
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13081.488     -13081.488     -13241.786     -13241.786      310.10728      310.10728      67457.811      67457.811      150.85728      150.85728    
     26000  -13089.191     -13089.191     -13245.991     -13245.991      303.33855      303.33855      67435.258      67435.258      163.17728      163.17728    
Loop time of 45.7627 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.888 ns/day, 12.712 hours/ns, 21.852 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.598     | 45.598     | 45.598     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019825   | 0.019825   | 0.019825   |   0.0 |  0.04
Output  | 4.745e-05  | 4.745e-05  | 4.745e-05  |   0.0 |  0.00
Modify  | 0.12573    | 0.12573    | 0.12573    |   0.0 |  0.27
Other   |            | 0.01901    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4069 ave        4069 max        4069 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:       214742 ave      214742 max      214742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214742
Ave neighs/atom = 53.6855
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 = 312.63174172548, Press = -0.826406754427011
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13089.191     -13089.191     -13245.991     -13245.991      303.33855      303.33855      67435.258      67435.258      163.17728      163.17728    
     27000  -13081.273     -13081.273     -13245.461     -13245.461      317.63226      317.63226      67457.215      67457.215      59.219768      59.219768    
Loop time of 45.6684 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.892 ns/day, 12.686 hours/ns, 21.897 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.507     | 45.507     | 45.507     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019166   | 0.019166   | 0.019166   |   0.0 |  0.04
Output  | 3.2982e-05 | 3.2982e-05 | 3.2982e-05 |   0.0 |  0.00
Modify  | 0.12461    | 0.12461    | 0.12461    |   0.0 |  0.27
Other   |            | 0.01743    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4072 ave        4072 max        4072 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:       214766 ave      214766 max      214766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214766
Ave neighs/atom = 53.6915
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 = 312.607607883966, Press = -0.928665677609717
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13081.273     -13081.273     -13245.461     -13245.461      317.63226      317.63226      67457.215      67457.215      59.219768      59.219768    
     28000  -13086.917     -13086.917     -13248.84      -13248.84       313.25127      313.25127      67454.799      67454.799     -57.032352     -57.032352    
Loop time of 45.6435 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.893 ns/day, 12.679 hours/ns, 21.909 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.482     | 45.482     | 45.482     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019185   | 0.019185   | 0.019185   |   0.0 |  0.04
Output  | 4.3642e-05 | 4.3642e-05 | 4.3642e-05 |   0.0 |  0.00
Modify  | 0.12463    | 0.12463    | 0.12463    |   0.0 |  0.27
Other   |            | 0.01729    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4105 ave        4105 max        4105 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:       214752 ave      214752 max      214752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214752
Ave neighs/atom = 53.688
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 = 312.55548722652, Press = -0.207668270766645
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13086.917     -13086.917     -13248.84      -13248.84       313.25127      313.25127      67454.799      67454.799     -57.032352     -57.032352    
     29000  -13081.71      -13081.71      -13244.915     -13244.915      315.73168      315.73168      67526.826      67526.826     -547.18094     -547.18094    
Loop time of 45.4648 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.629 hours/ns, 21.995 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 45.304     | 45.304     | 45.304     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019351   | 0.019351   | 0.019351   |   0.0 |  0.04
Output  | 4.5505e-05 | 4.5505e-05 | 4.5505e-05 |   0.0 |  0.00
Modify  | 0.12436    | 0.12436    | 0.12436    |   0.0 |  0.27
Other   |            | 0.01724    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4086 ave        4086 max        4086 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:       214760 ave      214760 max      214760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214760
Ave neighs/atom = 53.69
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 = 312.57019234657, Press = -1.51662536494218
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13081.71      -13081.71      -13244.915     -13244.915      315.73168      315.73168      67526.826      67526.826     -547.18094     -547.18094    
     30000  -13082.31      -13082.31      -13244.239     -13244.239      313.2631       313.2631       67369.04       67369.04       962.95787      962.95787    
Loop time of 45.3898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.608 hours/ns, 22.031 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    | 45.242     | 45.242     | 45.242     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016021   | 0.016021   | 0.016021   |   0.0 |  0.04
Output  | 3.72e-05   | 3.72e-05   | 3.72e-05   |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.27
Other   |            | 0.01046    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4056 ave        4056 max        4056 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:       214684 ave      214684 max      214684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214684
Ave neighs/atom = 53.671
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 = 312.596680038497, Press = -1.44085868014693
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 = 14 14 14
  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) = 4.146 | 4.146 | 4.146 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13082.31      -13082.31      -13244.239     -13244.239      313.2631       313.2631       67369.04       67369.04       962.95787      962.95787    
     31000  -13077.901     -13077.901     -13241.484     -13241.484      316.46187      316.46187      67471.526      67471.526      147.86135      147.86135    
Loop time of 45.5097 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.898 ns/day, 12.642 hours/ns, 21.973 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    | 45.363     | 45.363     | 45.363     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015906   | 0.015906   | 0.015906   |   0.0 |  0.03
Output  | 2.8584e-05 | 2.8584e-05 | 2.8584e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.27
Other   |            | 0.009557   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4128 ave        4128 max        4128 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:       214738 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.6845
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 = 312.649387453788, Press = 1.34523540991638
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13077.901     -13077.901     -13241.484     -13241.484      316.46187      316.46187      67471.526      67471.526      147.86135      147.86135    
     32000  -13084.839     -13084.839     -13244.969     -13244.969      309.78204      309.78204      67544.569      67544.569     -756.76618     -756.76618    
Loop time of 45.4895 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.899 ns/day, 12.636 hours/ns, 21.983 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    | 45.343     | 45.343     | 45.343     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01562    | 0.01562    | 0.01562    |   0.0 |  0.03
Output  | 3.8893e-05 | 3.8893e-05 | 3.8893e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.27
Other   |            | 0.009429   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4061 ave        4061 max        4061 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:       214626 ave      214626 max      214626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214626
Ave neighs/atom = 53.6565
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 = 312.747618667025, Press = -1.30366903675686
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13084.839     -13084.839     -13244.969     -13244.969      309.78204      309.78204      67544.569      67544.569     -756.76618     -756.76618    
     33000  -13081.223     -13081.223     -13243.889     -13243.889      314.68816      314.68816      67439.827      67439.827      291.59954      291.59954    
Loop time of 45.3737 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.904 ns/day, 12.604 hours/ns, 22.039 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    | 45.228     | 45.228     | 45.228     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015607   | 0.015607   | 0.015607   |   0.0 |  0.03
Output  | 3.8292e-05 | 3.8292e-05 | 3.8292e-05 |   0.0 |  0.00
Modify  | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.27
Other   |            | 0.009447   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4049 ave        4049 max        4049 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:       214644 ave      214644 max      214644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214644
Ave neighs/atom = 53.661
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 = 312.759655135057, Press = -1.11281432422432
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13081.223     -13081.223     -13243.889     -13243.889      314.68816      314.68816      67439.827      67439.827      291.59954      291.59954    
     34000  -13083.913     -13083.913     -13245.59      -13245.59       312.77501      312.77501      67451.49       67451.49       98.611477      98.611477    
Loop time of 45.3344 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.906 ns/day, 12.593 hours/ns, 22.058 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    | 45.188     | 45.188     | 45.188     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015721   | 0.015721   | 0.015721   |   0.0 |  0.03
Output  | 3.696e-05  | 3.696e-05  | 3.696e-05  |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.27
Other   |            | 0.009559   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4072 ave        4072 max        4072 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:       214738 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.6845
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 = 312.746659293282, Press = -0.26828351532816
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13083.913     -13083.913     -13245.59      -13245.59       312.77501      312.77501      67451.49       67451.49       98.611477      98.611477    
     35000  -13085.781     -13085.781     -13247.197     -13247.197      312.26999      312.26999      67504.612      67504.612     -465.77373     -465.77373    
Loop time of 45.5271 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.898 ns/day, 12.646 hours/ns, 21.965 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    | 45.381     | 45.381     | 45.381     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015709   | 0.015709   | 0.015709   |   0.0 |  0.03
Output  | 2.9005e-05 | 2.9005e-05 | 2.9005e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.27
Other   |            | 0.00944    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4041 ave        4041 max        4041 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:       214770 ave      214770 max      214770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214770
Ave neighs/atom = 53.6925
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 = 312.68050741096, Press = -0.833134263935281
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13085.781     -13085.781     -13247.197     -13247.197      312.26999      312.26999      67504.612      67504.612     -465.77373     -465.77373    
     36000  -13084.421     -13084.421     -13244.862     -13244.862      310.38409      310.38409      67407.897      67407.897      529.94663      529.94663    
Loop time of 45.7703 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.888 ns/day, 12.714 hours/ns, 21.848 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    | 45.623     | 45.623     | 45.623     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015704   | 0.015704   | 0.015704   |   0.0 |  0.03
Output  | 3.8362e-05 | 3.8362e-05 | 3.8362e-05 |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.27
Other   |            | 0.0095     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4027 ave        4027 max        4027 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:       214664 ave      214664 max      214664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214664
Ave neighs/atom = 53.666
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 = 312.694352702879, Press = -1.45101395058498
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13084.421     -13084.421     -13244.862     -13244.862      310.38409      310.38409      67407.897      67407.897      529.94663      529.94663    
     37000  -13081.886     -13081.886     -13243.332     -13243.332      312.3279       312.3279       67412.323      67412.323      598.57402      598.57402    
Loop time of 46.1412 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.873 ns/day, 12.817 hours/ns, 21.673 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    | 45.993     | 45.993     | 45.993     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.016078   | 0.016078   | 0.016078   |   0.0 |  0.03
Output  | 3.8492e-05 | 3.8492e-05 | 3.8492e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.27
Other   |            | 0.009546   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       214806 ave      214806 max      214806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214806
Ave neighs/atom = 53.7015
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 = 312.671259842189, Press = 0.399740238964448
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13081.886     -13081.886     -13243.332     -13243.332      312.3279       312.3279       67412.323      67412.323      598.57402      598.57402    
     38000  -13077.446     -13077.446     -13242.619     -13242.619      319.53931      319.53931      67600.698      67600.698     -1104.8793     -1104.8793    
Loop time of 45.7159 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.890 ns/day, 12.699 hours/ns, 21.874 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    | 45.568     | 45.568     | 45.568     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015784   | 0.015784   | 0.015784   |   0.0 |  0.03
Output  | 3.6438e-05 | 3.6438e-05 | 3.6438e-05 |   0.0 |  0.00
Modify  | 0.12234    | 0.12234    | 0.12234    |   0.0 |  0.27
Other   |            | 0.009496   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4071 ave        4071 max        4071 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:       214790 ave      214790 max      214790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214790
Ave neighs/atom = 53.6975
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 = 312.712986672127, Press = -0.533277509907816
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13077.446     -13077.446     -13242.619     -13242.619      319.53931      319.53931      67600.698      67600.698     -1104.8793     -1104.8793    
     39000  -13083.829     -13083.829     -13245.052     -13245.052      311.89686      311.89686      67443.93       67443.93       217.49839      217.49839    
Loop time of 45.5404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.897 ns/day, 12.650 hours/ns, 21.959 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    | 45.394     | 45.394     | 45.394     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015516   | 0.015516   | 0.015516   |   0.0 |  0.03
Output  | 3.6108e-05 | 3.6108e-05 | 3.6108e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.27
Other   |            | 0.0094     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4029 ave        4029 max        4029 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:       214624 ave      214624 max      214624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214624
Ave neighs/atom = 53.656
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 = 312.770439079725, Press = -1.59255078047305
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13083.829     -13083.829     -13245.052     -13245.052      311.89686      311.89686      67443.93       67443.93       217.49839      217.49839    
     40000  -13082.385     -13082.385     -13245.436     -13245.436      315.43322      315.43322      67423.302      67423.302      425.67209      425.67209    
Loop time of 45.9597 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.880 ns/day, 12.767 hours/ns, 21.758 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    | 45.812     | 45.812     | 45.812     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015887   | 0.015887   | 0.015887   |   0.0 |  0.03
Output  | 3.9554e-05 | 3.9554e-05 | 3.9554e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   0.0 |  0.27
Other   |            | 0.009573   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4079 ave        4079 max        4079 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:       214692 ave      214692 max      214692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214692
Ave neighs/atom = 53.673
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 = 312.80547302098, Press = -0.305442022034206
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13082.385     -13082.385     -13245.436     -13245.436      315.43322      315.43322      67423.302      67423.302      425.67209      425.67209    
     41000  -13076.493     -13076.493     -13242.102     -13242.102      320.38121      320.38121      67516.225      67516.225     -290.89985     -290.89985    
Loop time of 46.1446 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.872 ns/day, 12.818 hours/ns, 21.671 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    | 45.997     | 45.997     | 45.997     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015847   | 0.015847   | 0.015847   |   0.0 |  0.03
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.27
Other   |            | 0.009543   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4054 ave        4054 max        4054 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:       214780 ave      214780 max      214780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214780
Ave neighs/atom = 53.695
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 = 312.838553873949, Press = -0.403535997794205
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13076.493     -13076.493     -13242.102     -13242.102      320.38121      320.38121      67516.225      67516.225     -290.89985     -290.89985    
     42000  -13083.228     -13083.228     -13244.578     -13244.578      312.14315      312.14315      67481.975      67481.975     -143.59427     -143.59427    
Loop time of 45.6015 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.895 ns/day, 12.667 hours/ns, 21.929 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    | 45.455     | 45.455     | 45.455     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015754   | 0.015754   | 0.015754   |   0.0 |  0.03
Output  | 3.9024e-05 | 3.9024e-05 | 3.9024e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.27
Other   |            | 0.009475   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4059 ave        4059 max        4059 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:       214636 ave      214636 max      214636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214636
Ave neighs/atom = 53.659
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 = 312.886261186101, Press = -0.839350777451528
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13083.228     -13083.228     -13244.578     -13244.578      312.14315      312.14315      67481.975      67481.975     -143.59427     -143.59427    
     43000  -13081.783     -13081.783     -13243.558     -13243.558      312.96605      312.96605      67422.742      67422.742      497.07829      497.07829    
Loop time of 45.4806 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.900 ns/day, 12.634 hours/ns, 21.987 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    | 45.334     | 45.334     | 45.334     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015608   | 0.015608   | 0.015608   |   0.0 |  0.03
Output  | 3.6058e-05 | 3.6058e-05 | 3.6058e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.27
Other   |            | 0.009402   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4016 ave        4016 max        4016 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:       214618 ave      214618 max      214618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214618
Ave neighs/atom = 53.6545
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 = 312.919614605022, Press = -0.58214868611238
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 = 14 14 14
  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) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13081.783     -13081.783     -13243.558     -13243.558      312.96605      312.96605      67422.742      67422.742      497.07829      497.07829    
     44000  -13085.57      -13085.57      -13246.76      -13246.76       311.83304      311.83304      67480.251      67480.251     -193.44846     -193.44846    
Loop time of 45.5106 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.898 ns/day, 12.642 hours/ns, 21.973 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    | 45.364     | 45.364     | 45.364     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015813   | 0.015813   | 0.015813   |   0.0 |  0.03
Output  | 3.0086e-05 | 3.0086e-05 | 3.0086e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.27
Other   |            | 0.009457   |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4068 ave        4068 max        4068 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:       214804 ave      214804 max      214804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214804
Ave neighs/atom = 53.701
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67465.1855690017

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0