# 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.0419338792562485*${_u_distance}
variable latticeconst_converted equal 4.0419338792562485*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04193387925625
Lattice spacing in x,y,z = 4.0419339 4.0419339 4.0419339
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.419339 40.419339 40.419339)
  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.419339 40.419339 40.419339)
  create_atoms CPU = 0.003 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_LeeLee_2010_FeAl__MO_332211522050_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 66034.0013456933    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66034.0013456933/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66034.0013456933/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66034.0013456933/(1*1*${_u_distance})
variable      V0_metal equal 66034.0013456933/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66034.0013456933*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66034.0013456933 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_332211522050_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  -13329.168     -13329.168     -13480.701     -13480.701      293.15         293.15         66034.001      66034.001      2451.0863      2451.0863    
      1000  -13151.192     -13151.192     -13311.867     -13311.867      310.83773      310.83773      67651.845      67651.845      597.61812      597.61812    
Loop time of 188.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.311 hours/ns, 5.310 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    | 187.45     | 187.45     | 187.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10779    | 0.10779    | 0.10779    |   0.0 |  0.06
Output  | 0.000235   | 0.000235   | 0.000235   |   0.0 |  0.00
Modify  | 0.669      | 0.669      | 0.669      |   0.0 |  0.36
Other   |            | 0.09118    |            |       |  0.05

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  -13151.192     -13151.192     -13311.867     -13311.867      310.83773      310.83773      67651.845      67651.845      597.61812      597.61812    
      2000  -13172.917     -13172.917     -13321.568     -13321.568      287.57533      287.57533      67606.447      67606.447     -1.0018216     -1.0018216    
Loop time of 198.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.105 hours/ns, 5.041 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    | 197.51     | 197.51     | 197.51     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11055    | 0.11055    | 0.11055    |   0.0 |  0.06
Output  | 0.00022545 | 0.00022545 | 0.00022545 |   0.0 |  0.00
Modify  | 0.663      | 0.663      | 0.663      |   0.0 |  0.33
Other   |            | 0.09213    |            |       |  0.05

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

Total # of neighbors = 214492
Ave neighs/atom = 53.623
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  -13172.917     -13172.917     -13321.568     -13321.568      287.57533      287.57533      67606.447      67606.447     -1.0018216     -1.0018216    
      3000  -13158.074     -13158.074     -13310.435     -13310.435      294.75317      294.75317      67681.892      67681.892      236.2195       236.2195     
Loop time of 200.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.637 hours/ns, 4.993 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    | 199.42     | 199.42     | 199.42     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11106    | 0.11106    | 0.11106    |   0.0 |  0.06
Output  | 0.00028446 | 0.00028446 | 0.00028446 |   0.0 |  0.00
Modify  | 0.67226    | 0.67226    | 0.67226    |   0.0 |  0.34
Other   |            | 0.09259    |            |       |  0.05

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

Total # of neighbors = 214758
Ave neighs/atom = 53.6895
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  -13158.074     -13158.074     -13310.435     -13310.435      294.75317      294.75317      67681.892      67681.892      236.2195       236.2195     
      4000  -13170.302     -13170.302     -13319.134     -13319.134      287.92601      287.92601      67616.822      67616.822      257.02628      257.02628    
Loop time of 200.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.633 hours/ns, 4.993 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    | 199.4      | 199.4      | 199.4      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11141    | 0.11141    | 0.11141    |   0.0 |  0.06
Output  | 0.00022826 | 0.00022826 | 0.00022826 |   0.0 |  0.00
Modify  | 0.67073    | 0.67073    | 0.67073    |   0.0 |  0.33
Other   |            | 0.09294    |            |       |  0.05

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

Total # of neighbors = 214530
Ave neighs/atom = 53.6325
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  -13170.302     -13170.302     -13319.134     -13319.134      287.92601      287.92601      67616.822      67616.822      257.02628      257.02628    
      5000  -13160.858     -13160.858     -13315.695     -13315.695      299.54169      299.54169      67682.28       67682.28      -257.75838     -257.75838    
Loop time of 200.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.732 hours/ns, 4.984 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    | 199.76     | 199.76     | 199.76     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1112     | 0.1112     | 0.1112     |   0.0 |  0.06
Output  | 0.00022405 | 0.00022405 | 0.00022405 |   0.0 |  0.00
Modify  | 0.67334    | 0.67334    | 0.67334    |   0.0 |  0.34
Other   |            | 0.09317    |            |       |  0.05

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

Total # of neighbors = 214634
Ave neighs/atom = 53.6585
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 = 296.381844333727, Press = -306.030847065425
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  -13160.858     -13160.858     -13315.695     -13315.695      299.54169      299.54169      67682.28       67682.28      -257.75838     -257.75838    
      6000  -13168.567     -13168.567     -13317.452     -13317.452      288.02952      288.02952      67699.885      67699.885     -635.71855     -635.71855    
Loop time of 201.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.904 hours/ns, 4.969 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    | 200.35     | 200.35     | 200.35     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11128    | 0.11128    | 0.11128    |   0.0 |  0.06
Output  | 0.00019038 | 0.00019038 | 0.00019038 |   0.0 |  0.00
Modify  | 0.70247    | 0.70247    | 0.70247    |   0.0 |  0.35
Other   |            | 0.09309    |            |       |  0.05

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

Total # of neighbors = 214456
Ave neighs/atom = 53.614
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 = 293.071885600715, Press = -16.8341057752721
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  -13168.567     -13168.567     -13317.452     -13317.452      288.02952      288.02952      67699.885      67699.885     -635.71855     -635.71855    
      7000  -13162.112     -13162.112     -13315.965     -13315.965      297.63782      297.63782      67788.328      67788.328     -1446.3554     -1446.3554    
Loop time of 200.75 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.764 hours/ns, 4.981 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    | 199.85     | 199.85     | 199.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1109     | 0.1109     | 0.1109     |   0.0 |  0.06
Output  | 0.0001877  | 0.0001877  | 0.0001877  |   0.0 |  0.00
Modify  | 0.70066    | 0.70066    | 0.70066    |   0.0 |  0.35
Other   |            | 0.09232    |            |       |  0.05

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

Total # of neighbors = 214566
Ave neighs/atom = 53.6415
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 = 293.32036439485, Press = -9.45735659579953
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  -13162.112     -13162.112     -13315.965     -13315.965      297.63782      297.63782      67788.328      67788.328     -1446.3554     -1446.3554    
      8000  -13164.712     -13164.712     -13316.206     -13316.206      293.07659      293.07659      67786.03       67786.03      -1284.5976     -1284.5976    
Loop time of 200.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.779 hours/ns, 4.980 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    | 199.9      | 199.9      | 199.9      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11122    | 0.11122    | 0.11122    |   0.0 |  0.06
Output  | 0.00022253 | 0.00022253 | 0.00022253 |   0.0 |  0.00
Modify  | 0.69899    | 0.69899    | 0.69899    |   0.0 |  0.35
Other   |            | 0.09303    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4051 ave        4051 max        4051 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 = 293.097300024191, Press = 2.94612912396237
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13164.712     -13164.712     -13316.206     -13316.206      293.07659      293.07659      67786.03       67786.03      -1284.5976     -1284.5976    
      9000  -13164.113     -13164.113     -13317.632     -13317.632      296.99239      296.99239      67691.625      67691.625     -478.23077     -478.23077    
Loop time of 200.148 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.597 hours/ns, 4.996 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    | 199.25     | 199.25     | 199.25     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10931    | 0.10931    | 0.10931    |   0.0 |  0.05
Output  | 0.00021556 | 0.00021556 | 0.00021556 |   0.0 |  0.00
Modify  | 0.69555    | 0.69555    | 0.69555    |   0.0 |  0.35
Other   |            | 0.0927     |            |       |  0.05

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

Total # of neighbors = 214408
Ave neighs/atom = 53.602
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 = 293.562982834345, Press = 2.12195399860111
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  -13164.113     -13164.113     -13317.632     -13317.632      296.99239      296.99239      67691.625      67691.625     -478.23077     -478.23077    
     10000  -13168.618     -13168.618     -13317.253     -13317.253      287.54573      287.54573      67664.652      67664.652     -111.15121     -111.15121    
Loop time of 201.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.940 hours/ns, 4.966 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    | 200.48     | 200.48     | 200.48     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10983    | 0.10983    | 0.10983    |   0.0 |  0.05
Output  | 0.00018724 | 0.00018724 | 0.00018724 |   0.0 |  0.00
Modify  | 0.702      | 0.702      | 0.702      |   0.0 |  0.35
Other   |            | 0.09265    |            |       |  0.05

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

Total # of neighbors = 214590
Ave neighs/atom = 53.6475
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 = 293.630534722916, Press = -1.37452960466869
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  -13168.618     -13168.618     -13317.253     -13317.253      287.54573      287.54573      67664.652      67664.652     -111.15121     -111.15121    
     11000  -13160.267     -13160.267     -13313.363     -13313.363      296.17581      296.17581      67689.776      67689.776     -180.86017     -180.86017    
Loop time of 202.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.321 hours/ns, 4.932 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    | 201.85     | 201.85     | 201.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11101    | 0.11101    | 0.11101    |   0.0 |  0.05
Output  | 0.00018553 | 0.00018553 | 0.00018553 |   0.0 |  0.00
Modify  | 0.7035     | 0.7035     | 0.7035     |   0.0 |  0.35
Other   |            | 0.09387    |            |       |  0.05

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

Total # of neighbors = 214616
Ave neighs/atom = 53.654
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 = 293.607219147801, Press = -1.2322159060371
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  -13160.267     -13160.267     -13313.363     -13313.363      296.17581      296.17581      67689.776      67689.776     -180.86017     -180.86017    
     12000  -13165.874     -13165.874     -13318.862     -13318.862      295.96637      295.96637      67622.341      67622.341      134.3729       134.3729     
Loop time of 200.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.579 hours/ns, 4.998 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    | 199.19     | 199.19     | 199.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10958    | 0.10958    | 0.10958    |   0.0 |  0.05
Output  | 0.00018719 | 0.00018719 | 0.00018719 |   0.0 |  0.00
Modify  | 0.69416    | 0.69416    | 0.69416    |   0.0 |  0.35
Other   |            | 0.09275    |            |       |  0.05

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

Total # of neighbors = 214582
Ave neighs/atom = 53.6455
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 = 293.712842915632, Press = -4.79981457826491
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  -13165.874     -13165.874     -13318.862     -13318.862      295.96637      295.96637      67622.341      67622.341      134.3729       134.3729     
     13000  -13163.908     -13163.908     -13317.013     -13317.013      296.19087      296.19087      67580.887      67580.887      969.74203      969.74203    
Loop time of 199.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.339 hours/ns, 5.020 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    | 198.32     | 198.32     | 198.32     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11164    | 0.11164    | 0.11164    |   0.0 |  0.06
Output  | 0.00019034 | 0.00019034 | 0.00019034 |   0.0 |  0.00
Modify  | 0.69279    | 0.69279    | 0.69279    |   0.0 |  0.35
Other   |            | 0.09208    |            |       |  0.05

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

Total # of neighbors = 214718
Ave neighs/atom = 53.6795
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 = 293.635256635679, Press = -6.01514894021254
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  -13163.908     -13163.908     -13317.013     -13317.013      296.19087      296.19087      67580.887      67580.887      969.74203      969.74203    
     14000  -13168.535     -13168.535     -13318.434     -13318.434      289.99014      289.99014      67611.796      67611.796      406.99085      406.99085    
Loop time of 199.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.507 hours/ns, 5.004 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    | 198.93     | 198.93     | 198.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11044    | 0.11044    | 0.11044    |   0.0 |  0.06
Output  | 0.00044929 | 0.00044929 | 0.00044929 |   0.0 |  0.00
Modify  | 0.69494    | 0.69494    | 0.69494    |   0.0 |  0.35
Other   |            | 0.09277    |            |       |  0.05

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

Total # of neighbors = 214662
Ave neighs/atom = 53.6655
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 = 293.427780823656, Press = -5.22801495715775
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  -13168.535     -13168.535     -13318.434     -13318.434      289.99014      289.99014      67611.796      67611.796      406.99085      406.99085    
     15000  -13161.401     -13161.401     -13315.608     -13315.608      298.32479      298.32479      67620.677      67620.677      573.46668      573.46668    
Loop time of 201.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.965 hours/ns, 4.963 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    | 200.57     | 200.57     | 200.57     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11167    | 0.11167    | 0.11167    |   0.0 |  0.06
Output  | 0.0002307  | 0.0002307  | 0.0002307  |   0.0 |  0.00
Modify  | 0.70408    | 0.70408    | 0.70408    |   0.0 |  0.35
Other   |            | 0.09311    |            |       |  0.05

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

Total # of neighbors = 214650
Ave neighs/atom = 53.6625
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 = 293.305961150682, Press = -4.29354010247142
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  -13161.401     -13161.401     -13315.608     -13315.608      298.32479      298.32479      67620.677      67620.677      573.46668      573.46668    
     16000  -13163.897     -13163.897     -13316.788     -13316.788      295.77831      295.77831      67653.458      67653.458      137.44857      137.44857    
Loop time of 199.45 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.403 hours/ns, 5.014 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    | 198.56     | 198.56     | 198.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11036    | 0.11036    | 0.11036    |   0.0 |  0.06
Output  | 0.00018741 | 0.00018741 | 0.00018741 |   0.0 |  0.00
Modify  | 0.69181    | 0.69181    | 0.69181    |   0.0 |  0.35
Other   |            | 0.09244    |            |       |  0.05

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

Total # of neighbors = 214646
Ave neighs/atom = 53.6615
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 = 293.40701884249, Press = -3.80847113559363
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13163.897     -13163.897     -13316.788     -13316.788      295.77831      295.77831      67653.458      67653.458      137.44857      137.44857    
     17000  -13161.71      -13161.71      -13315.865     -13315.865      298.22301      298.22301      67649.727      67649.727      142.62329      142.62329    
Loop time of 199.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.475 hours/ns, 5.007 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    | 198.82     | 198.82     | 198.82     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10945    | 0.10945    | 0.10945    |   0.0 |  0.05
Output  | 0.00018653 | 0.00018653 | 0.00018653 |   0.0 |  0.00
Modify  | 0.69189    | 0.69189    | 0.69189    |   0.0 |  0.35
Other   |            | 0.09221    |            |       |  0.05

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

Total # of neighbors = 214646
Ave neighs/atom = 53.6615
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 = 293.437840935505, Press = -2.6295089489761
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  -13161.71      -13161.71      -13315.865     -13315.865      298.22301      298.22301      67649.727      67649.727      142.62329      142.62329    
     18000  -13165.113     -13165.113     -13313.686     -13313.686      287.42308      287.42308      67667.763      67667.763      131.57134      131.57134    
Loop time of 200.188 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.608 hours/ns, 4.995 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    | 199.29     | 199.29     | 199.29     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11047    | 0.11047    | 0.11047    |   0.0 |  0.06
Output  | 0.00022864 | 0.00022864 | 0.00022864 |   0.0 |  0.00
Modify  | 0.69004    | 0.69004    | 0.69004    |   0.0 |  0.34
Other   |            | 0.09272    |            |       |  0.05

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

Total # of neighbors = 214582
Ave neighs/atom = 53.6455
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 = 293.517374503053, Press = -2.96954773499143
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  -13165.113     -13165.113     -13313.686     -13313.686      287.42308      287.42308      67667.763      67667.763      131.57134      131.57134    
     19000  -13168.513     -13168.513     -13319.665     -13319.665      292.41297      292.41297      67640.868      67640.868     -161.86861     -161.86861    
Loop time of 199.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.352 hours/ns, 5.018 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    | 198.37     | 198.37     | 198.37     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11052    | 0.11052    | 0.11052    |   0.0 |  0.06
Output  | 0.00018685 | 0.00018685 | 0.00018685 |   0.0 |  0.00
Modify  | 0.69001    | 0.69001    | 0.69001    |   0.0 |  0.35
Other   |            | 0.09331    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4078 ave        4078 max        4078 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 = 293.357498455588, Press = -3.18432964455982
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  -13168.513     -13168.513     -13319.665     -13319.665      292.41297      292.41297      67640.868      67640.868     -161.86861     -161.86861    
     20000  -13161.72      -13161.72      -13314.832     -13314.832      296.20589      296.20589      67720.401      67720.401     -676.62642     -676.62642    
Loop time of 200.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.757 hours/ns, 4.982 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    | 199.82     | 199.82     | 199.82     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11053    | 0.11053    | 0.11053    |   0.0 |  0.06
Output  | 0.00018535 | 0.00018535 | 0.00018535 |   0.0 |  0.00
Modify  | 0.69648    | 0.69648    | 0.69648    |   0.0 |  0.35
Other   |            | 0.093      |            |       |  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:       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 = 293.31895625243, Press = -4.94810663268192
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  -13161.72      -13161.72      -13314.832     -13314.832      296.20589      296.20589      67720.401      67720.401     -676.62642     -676.62642    
     21000  -13169.623     -13169.623     -13320.252     -13320.252      291.40157      291.40157      67709.125      67709.125     -897.90919     -897.90919    
Loop time of 199.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.547 hours/ns, 5.001 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    | 199.07     | 199.07     | 199.07     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11095    | 0.11095    | 0.11095    |   0.0 |  0.06
Output  | 0.00018997 | 0.00018997 | 0.00018997 |   0.0 |  0.00
Modify  | 0.69494    | 0.69494    | 0.69494    |   0.0 |  0.35
Other   |            | 0.09278    |            |       |  0.05

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

Total # of neighbors = 214476
Ave neighs/atom = 53.619
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 = 293.238283574081, Press = -1.73819663240365
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  -13169.623     -13169.623     -13320.252     -13320.252      291.40157      291.40157      67709.125      67709.125     -897.90919     -897.90919    
     22000  -13162.676     -13162.676     -13314.034     -13314.034      292.81071      292.81071      67737.353      67737.353     -697.65892     -697.65892    
Loop time of 201.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.001 hours/ns, 4.960 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    | 200.69     | 200.69     | 200.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11083    | 0.11083    | 0.11083    |   0.0 |  0.05
Output  | 0.00018867 | 0.00018867 | 0.00018867 |   0.0 |  0.00
Modify  | 0.70519    | 0.70519    | 0.70519    |   0.0 |  0.35
Other   |            | 0.09279    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3996 ave        3996 max        3996 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 = 293.185978379794, Press = -1.47380038866681
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  -13162.676     -13162.676     -13314.034     -13314.034      292.81071      292.81071      67737.353      67737.353     -697.65892     -697.65892    
     23000  -13169.431     -13169.431     -13320.756     -13320.756      292.75027      292.75027      67738.048      67738.048     -1153.8287     -1153.8287    
Loop time of 201.384 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.940 hours/ns, 4.966 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    | 200.48     | 200.48     | 200.48     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11069    | 0.11069    | 0.11069    |   0.0 |  0.05
Output  | 0.00018981 | 0.00018981 | 0.00018981 |   0.0 |  0.00
Modify  | 0.70399    | 0.70399    | 0.70399    |   0.0 |  0.35
Other   |            | 0.09303    |            |       |  0.05

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

Total # of neighbors = 214334
Ave neighs/atom = 53.5835
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 = 293.104891692229, Press = -0.269902536665493
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  -13169.431     -13169.431     -13320.756     -13320.756      292.75027      292.75027      67738.048      67738.048     -1153.8287     -1153.8287    
     24000  -13163.189     -13163.189     -13317.457     -13317.457      298.44035      298.44035      67723.442      67723.442     -746.12869     -746.12869    
Loop time of 200.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.582 hours/ns, 4.998 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    | 199.19     | 199.19     | 199.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11085    | 0.11085    | 0.11085    |   0.0 |  0.06
Output  | 0.00018829 | 0.00018829 | 0.00018829 |   0.0 |  0.00
Modify  | 0.69951    | 0.69951    | 0.69951    |   0.0 |  0.35
Other   |            | 0.09266    |            |       |  0.05

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

Total # of neighbors = 214612
Ave neighs/atom = 53.653
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 = 293.043941778793, Press = 1.05252249060646
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  -13163.189     -13163.189     -13317.457     -13317.457      298.44035      298.44035      67723.442      67723.442     -746.12869     -746.12869    
     25000  -13167.897     -13167.897     -13317.092     -13317.092      288.6266       288.6266       67649.191      67649.191     -125.00517     -125.00517    
Loop time of 200.844 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.790 hours/ns, 4.979 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    | 199.94     | 199.94     | 199.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11025    | 0.11025    | 0.11025    |   0.0 |  0.05
Output  | 0.00018881 | 0.00018881 | 0.00018881 |   0.0 |  0.00
Modify  | 0.69695    | 0.69695    | 0.69695    |   0.0 |  0.35
Other   |            | 0.09295    |            |       |  0.05

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

Total # of neighbors = 214600
Ave neighs/atom = 53.65
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
67658.8360368877

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0