# 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.005 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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  -13339.507     -13339.507     -13480.701     -13480.701      273.15         273.15         66034.001      66034.001      2283.8627      2283.8627    
      1000  -13174.536     -13174.536     -13325.189     -13325.189      291.44823      291.44823      67607.581      67607.581     -15.888455     -15.888455    
Loop time of 187.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.086 hours/ns, 5.333 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    | 186.63     | 186.63     | 186.63     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11089    | 0.11089    | 0.11089    |   0.0 |  0.06
Output  | 0.00023615 | 0.00023615 | 0.00023615 |   0.0 |  0.00
Modify  | 0.67785    | 0.67785    | 0.67785    |   0.0 |  0.36
Other   |            | 0.09174    |            |       |  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  -13174.536     -13174.536     -13325.189     -13325.189      291.44823      291.44823      67607.581      67607.581     -15.888455     -15.888455    
      2000  -13194.64      -13194.64      -13331.603     -13331.603      264.96555      264.96555      67523.401      67523.401      367.04544      367.04544    
Loop time of 198.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.258 hours/ns, 5.027 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.05     | 198.05     | 198.05     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11234    | 0.11234    | 0.11234    |   0.0 |  0.06
Output  | 0.00025287 | 0.00025287 | 0.00025287 |   0.0 |  0.00
Modify  | 0.6769     | 0.6769     | 0.6769     |   0.0 |  0.34
Other   |            | 0.09348    |            |       |  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:       214822 ave      214822 max      214822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214822
Ave neighs/atom = 53.7055
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  -13194.64      -13194.64      -13331.603     -13331.603      264.96555      264.96555      67523.401      67523.401      367.04544      367.04544    
      3000  -13180.749     -13180.749     -13322.803     -13322.803      274.81354      274.81354      67615.625      67615.625      1.1596752      1.1596752    
Loop time of 198.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.130 hours/ns, 5.039 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.59     | 197.59     | 197.59     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11162    | 0.11162    | 0.11162    |   0.0 |  0.06
Output  | 0.00022421 | 0.00022421 | 0.00022421 |   0.0 |  0.00
Modify  | 0.66957    | 0.66957    | 0.66957    |   0.0 |  0.34
Other   |            | 0.09142    |            |       |  0.05

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

Total # of neighbors = 214952
Ave neighs/atom = 53.738
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  -13180.749     -13180.749     -13322.803     -13322.803      274.81354      274.81354      67615.625      67615.625      1.1596752      1.1596752    
      4000  -13191.66      -13191.66      -13330.267     -13330.267      268.14409      268.14409      67554.335      67554.335      277.56069      277.56069    
Loop time of 199.029 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.286 hours/ns, 5.024 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.15     | 198.15     | 198.15     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11198    | 0.11198    | 0.11198    |   0.0 |  0.06
Output  | 0.00022988 | 0.00022988 | 0.00022988 |   0.0 |  0.00
Modify  | 0.67066    | 0.67066    | 0.67066    |   0.0 |  0.34
Other   |            | 0.09212    |            |       |  0.05

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

Total # of neighbors = 214812
Ave neighs/atom = 53.703
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  -13191.66      -13191.66      -13330.267     -13330.267      268.14409      268.14409      67554.335      67554.335      277.56069      277.56069    
      5000  -13184.005     -13184.005     -13327.656     -13327.656      277.90266      277.90266      67651.532      67651.532     -790.17474     -790.17474    
Loop time of 199.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.429 hours/ns, 5.011 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.66     | 198.66     | 198.66     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11131    | 0.11131    | 0.11131    |   0.0 |  0.06
Output  | 0.00025099 | 0.00025099 | 0.00025099 |   0.0 |  0.00
Modify  | 0.67834    | 0.67834    | 0.67834    |   0.0 |  0.34
Other   |            | 0.09337    |            |       |  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:       214948 ave      214948 max      214948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214948
Ave neighs/atom = 53.737
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 = 275.963557068178, Press = 164.402981135273
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  -13184.005     -13184.005     -13327.656     -13327.656      277.90266      277.90266      67651.532      67651.532     -790.17474     -790.17474    
      6000  -13189.144     -13189.144     -13330.294     -13330.294      273.06364      273.06364      67686.276      67686.276     -1428.0549     -1428.0549    
Loop time of 199.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.351 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.36     | 198.36     | 198.36     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11173    | 0.11173    | 0.11173    |   0.0 |  0.06
Output  | 0.00018869 | 0.00018869 | 0.00018869 |   0.0 |  0.00
Modify  | 0.69903    | 0.69903    | 0.69903    |   0.0 |  0.35
Other   |            | 0.09245    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4002 ave        4002 max        4002 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 = 272.857839120306, Press = -10.3666467361205
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   
      6000  -13189.144     -13189.144     -13330.294     -13330.294      273.06364      273.06364      67686.276      67686.276     -1428.0549     -1428.0549    
      7000  -13185.961     -13185.961     -13326.707     -13326.707      272.28422      272.28422      67626.263      67626.263     -469.62174     -469.62174    
Loop time of 199.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.458 hours/ns, 5.009 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.74     | 198.74     | 198.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11098    | 0.11098    | 0.11098    |   0.0 |  0.06
Output  | 0.00023526 | 0.00023526 | 0.00023526 |   0.0 |  0.00
Modify  | 0.70113    | 0.70113    | 0.70113    |   0.0 |  0.35
Other   |            | 0.09205    |            |       |  0.05

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

Total # of neighbors = 214868
Ave neighs/atom = 53.717
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 = 273.262637233037, Press = -8.96644569816187
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  -13185.961     -13185.961     -13326.707     -13326.707      272.28422      272.28422      67626.263      67626.263     -469.62174     -469.62174    
      8000  -13184.238     -13184.238     -13327.282     -13327.282      276.72898      276.72898      67567.588      67567.588      71.192325      71.192325    
Loop time of 199.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.460 hours/ns, 5.009 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.75     | 198.75     | 198.75     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11069    | 0.11069    | 0.11069    |   0.0 |  0.06
Output  | 0.00029247 | 0.00029247 | 0.00029247 |   0.0 |  0.00
Modify  | 0.70144    | 0.70144    | 0.70144    |   0.0 |  0.35
Other   |            | 0.09322    |            |       |  0.05

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

Total # of neighbors = 214728
Ave neighs/atom = 53.682
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 = 273.081926427822, Press = 0.798976214954539
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  -13184.238     -13184.238     -13327.282     -13327.282      276.72898      276.72898      67567.588      67567.588      71.192325      71.192325    
      9000  -13189.888     -13189.888     -13330.471     -13330.471      271.96737      271.96737      67503.835      67503.835      659.16863      659.16863    
Loop time of 198.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.162 hours/ns, 5.036 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.68     | 197.68     | 197.68     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11198    | 0.11198    | 0.11198    |   0.0 |  0.06
Output  | 0.00018775 | 0.00018775 | 0.00018775 |   0.0 |  0.00
Modify  | 0.69876    | 0.69876    | 0.69876    |   0.0 |  0.35
Other   |            | 0.09239    |            |       |  0.05

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

Total # of neighbors = 214868
Ave neighs/atom = 53.717
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 = 273.351512466378, Press = 1.38818155660891
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  -13189.888     -13189.888     -13330.471     -13330.471      271.96737      271.96737      67503.835      67503.835      659.16863      659.16863    
     10000  -13186.75      -13186.75      -13327.754     -13327.754      272.78257      272.78257      67534.264      67534.264      492.11449      492.11449    
Loop time of 199.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.278 hours/ns, 5.025 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.1      | 198.1      | 198.1      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11194    | 0.11194    | 0.11194    |   0.0 |  0.06
Output  | 0.00018792 | 0.00018792 | 0.00018792 |   0.0 |  0.00
Modify  | 0.69992    | 0.69992    | 0.69992    |   0.0 |  0.35
Other   |            | 0.09338    |            |       |  0.05

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

Total # of neighbors = 215078
Ave neighs/atom = 53.7695
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 = 273.257088375706, Press = 1.8712642580366
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  -13186.75      -13186.75      -13327.754     -13327.754      272.78257      272.78257      67534.264      67534.264      492.11449      492.11449    
     11000  -13186.539     -13186.539     -13329.089     -13329.089      275.77267      275.77267      67466.76       67466.76       1226.7299      1226.7299    
Loop time of 200.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.656 hours/ns, 4.991 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.45     | 199.45     | 199.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11243    | 0.11243    | 0.11243    |   0.0 |  0.06
Output  | 0.00018823 | 0.00018823 | 0.00018823 |   0.0 |  0.00
Modify  | 0.70656    | 0.70656    | 0.70656    |   0.0 |  0.35
Other   |            | 0.09226    |            |       |  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:       214874 ave      214874 max      214874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214874
Ave neighs/atom = 53.7185
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 = 273.190295913422, Press = 1.15586159035884
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  -13186.539     -13186.539     -13329.089     -13329.089      275.77267      275.77267      67466.76       67466.76       1226.7299      1226.7299    
     12000  -13185.509     -13185.509     -13327.057     -13327.057      273.83461      273.83461      67473.543      67473.543      1096.722       1096.722     
Loop time of 199.644 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.457 hours/ns, 5.009 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.74     | 198.74     | 198.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11216    | 0.11216    | 0.11216    |   0.0 |  0.06
Output  | 0.00018713 | 0.00018713 | 0.00018713 |   0.0 |  0.00
Modify  | 0.69701    | 0.69701    | 0.69701    |   0.0 |  0.35
Other   |            | 0.09225    |            |       |  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:       214902 ave      214902 max      214902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214902
Ave neighs/atom = 53.7255
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 = 273.321798886871, Press = 5.90439975381805
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  -13185.509     -13185.509     -13327.057     -13327.057      273.83461      273.83461      67473.543      67473.543      1096.722       1096.722     
     13000  -13183.871     -13183.871     -13326.208     -13326.208      275.36066      275.36066      67620.002      67620.002     -328.408       -328.408      
Loop time of 199.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.304 hours/ns, 5.023 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.18     | 198.18     | 198.18     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11349    | 0.11349    | 0.11349    |   0.0 |  0.06
Output  | 0.00018836 | 0.00018836 | 0.00018836 |   0.0 |  0.00
Modify  | 0.70425    | 0.70425    | 0.70425    |   0.0 |  0.35
Other   |            | 0.09301    |            |       |  0.05

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

Total # of neighbors = 214920
Ave neighs/atom = 53.73
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 = 273.250559407773, Press = 2.67056055005082
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  -13183.871     -13183.871     -13326.208     -13326.208      275.36066      275.36066      67620.002      67620.002     -328.408       -328.408      
     14000  -13185.882     -13185.882     -13328.741     -13328.741      276.37027      276.37027      67628.942      67628.942     -612.92184     -612.92184    
Loop time of 198.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.118 hours/ns, 5.040 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.52     | 197.52     | 197.52     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11185    | 0.11185    | 0.11185    |   0.0 |  0.06
Output  | 0.00051257 | 0.00051257 | 0.00051257 |   0.0 |  0.00
Modify  | 0.69502    | 0.69502    | 0.69502    |   0.0 |  0.35
Other   |            | 0.0928     |            |       |  0.05

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

Total # of neighbors = 214818
Ave neighs/atom = 53.7045
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 = 273.392080398494, Press = 1.72347905334226
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  -13185.882     -13185.882     -13328.741     -13328.741      276.37027      276.37027      67628.942      67628.942     -612.92184     -612.92184    
     15000  -13187.085     -13187.085     -13324.763     -13324.763      266.34783      266.34783      67593.069      67593.069     -120.12759     -120.12759    
Loop time of 198.613 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.170 hours/ns, 5.035 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.71     | 197.71     | 197.71     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11202    | 0.11202    | 0.11202    |   0.0 |  0.06
Output  | 0.00022937 | 0.00022937 | 0.00022937 |   0.0 |  0.00
Modify  | 0.69851    | 0.69851    | 0.69851    |   0.0 |  0.35
Other   |            | 0.09222    |            |       |  0.05

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

Total # of neighbors = 214854
Ave neighs/atom = 53.7135
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 = 273.365963296418, Press = 0.548671271421212
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  -13187.085     -13187.085     -13324.763     -13324.763      266.34783      266.34783      67593.069      67593.069     -120.12759     -120.12759    
     16000  -13191.453     -13191.453     -13329.165     -13329.165      266.41288      266.41288      67551.089      67551.089      196.30437      196.30437    
Loop time of 199.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.390 hours/ns, 5.015 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.5      | 198.5      | 198.5      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11039    | 0.11039    | 0.11039    |   0.0 |  0.06
Output  | 0.00018863 | 0.00018863 | 0.00018863 |   0.0 |  0.00
Modify  | 0.695      | 0.695      | 0.695      |   0.0 |  0.35
Other   |            | 0.0929     |            |       |  0.05

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

Total # of neighbors = 214814
Ave neighs/atom = 53.7035
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 = 273.299735593645, Press = 1.26045073856458
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  -13191.453     -13191.453     -13329.165     -13329.165      266.41288      266.41288      67551.089      67551.089      196.30437      196.30437    
     17000  -13186.347     -13186.347     -13329.47      -13329.47       276.88223      276.88223      67640.58       67640.58      -775.16689     -775.16689    
Loop time of 199.27 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.353 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.36     | 198.36     | 198.36     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11402    | 0.11402    | 0.11402    |   0.0 |  0.06
Output  | 0.00022759 | 0.00022759 | 0.00022759 |   0.0 |  0.00
Modify  | 0.70544    | 0.70544    | 0.70544    |   0.0 |  0.35
Other   |            | 0.09347    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4050 ave        4050 max        4050 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 = 273.184605136734, Press = 0.912022605018254
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  -13186.347     -13186.347     -13329.47      -13329.47       276.88223      276.88223      67640.58       67640.58      -775.16689     -775.16689    
     18000  -13187.633     -13187.633     -13329.481     -13329.481      274.41458      274.41458      67684.862      67684.862     -1330.1935     -1330.1935    
Loop time of 197.556 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.877 hours/ns, 5.062 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    | 196.66     | 196.66     | 196.66     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11168    | 0.11168    | 0.11168    |   0.0 |  0.06
Output  | 0.00018961 | 0.00018961 | 0.00018961 |   0.0 |  0.00
Modify  | 0.69057    | 0.69057    | 0.69057    |   0.0 |  0.35
Other   |            | 0.09215    |            |       |  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:       214878 ave      214878 max      214878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214878
Ave neighs/atom = 53.7195
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 = 273.190873104549, Press = -1.92022861001936
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  -13187.633     -13187.633     -13329.481     -13329.481      274.41458      274.41458      67684.862      67684.862     -1330.1935     -1330.1935    
     19000  -13184.46      -13184.46      -13327.358     -13327.358      276.44435      276.44435      67597.115      67597.115     -28.935698     -28.935698    
Loop time of 199.096 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.305 hours/ns, 5.023 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.2      | 198.2      | 198.2      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11093    | 0.11093    | 0.11093    |   0.0 |  0.06
Output  | 0.0002606  | 0.0002606  | 0.0002606  |   0.0 |  0.00
Modify  | 0.69423    | 0.69423    | 0.69423    |   0.0 |  0.35
Other   |            | 0.09207    |            |       |  0.05

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

Total # of neighbors = 214872
Ave neighs/atom = 53.718
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 = 273.269847542229, Press = -1.85068695447272
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  -13184.46      -13184.46      -13327.358     -13327.358      276.44435      276.44435      67597.115      67597.115     -28.935698     -28.935698    
     20000  -13186.955     -13186.955     -13329.904     -13329.904      276.54465      276.54465      67562.763      67562.763      102.05899      102.05899    
Loop time of 198.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.149 hours/ns, 5.037 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    | 197.63     | 197.63     | 197.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11199    | 0.11199    | 0.11199    |   0.0 |  0.06
Output  | 0.00018795 | 0.00018795 | 0.00018795 |   0.0 |  0.00
Modify  | 0.69764    | 0.69764    | 0.69764    |   0.0 |  0.35
Other   |            | 0.09306    |            |       |  0.05

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

Total # of neighbors = 214858
Ave neighs/atom = 53.7145
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
67577.9263427916

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0