# 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.049999177455902*${_u_distance}
variable latticeconst_converted equal 4.049999177455902*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.0499991774559
Lattice spacing in x,y,z = 4.0499992 4.0499992 4.0499992
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.499992 40.499992 40.499992)
  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.499992 40.499992 40.499992)
  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_JelinekGrohHorstemeyer_2012_AlSiMgCuFe__MO_262519520678_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 66430.0845246695    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0845246695/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0845246695/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0845246695/(1*1*${_u_distance})
variable      V0_metal equal 66430.0845246695/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66430.0845246695*1000

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

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

variable temp_converted equal 253.15*${_u_temperature}
variable temp_converted equal 253.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 253.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "253.15 - 0.2"
variable      T_up  equal  "253.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_262519520678_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13281.144     -13281.144     -13412         -13412          253.15         253.15         66430.085      66430.085      2104.0143      2104.0143    
      1000  -13141.987     -13141.987     -13283.643     -13283.643      274.04344      274.04344      67208.131      67208.131     -719.1535      -719.1535     
Loop time of 391.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.808 hours/ns, 2.553 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    | 390.79     | 390.79     | 390.79     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14526    | 0.14526    | 0.14526    |   0.0 |  0.04
Output  | 0.00024279 | 0.00024279 | 0.00024279 |   0.0 |  0.00
Modify  | 0.67413    | 0.67413    | 0.67413    |   0.0 |  0.17
Other   |            | 0.09787    |            |       |  0.02

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

Total # of neighbors = 312000
Ave neighs/atom = 78
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13141.987     -13141.987     -13283.643     -13283.643      274.04344      274.04344      67208.131      67208.131     -719.1535      -719.1535     
      2000  -13152.223     -13152.223     -13280.885     -13280.885      248.90515      248.90515      67181.236      67181.236     -510.10028     -510.10028    
Loop time of 411.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.348 hours/ns, 2.429 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    | 410.71     | 410.71     | 410.71     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.04
Output  | 0.00022672 | 0.00022672 | 0.00022672 |   0.0 |  0.00
Modify  | 0.69486    | 0.69486    | 0.69486    |   0.0 |  0.17
Other   |            | 0.09981    |            |       |  0.02

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

Total # of neighbors = 323322
Ave neighs/atom = 80.8305
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13152.223     -13152.223     -13280.885     -13280.885      248.90515      248.90515      67181.236      67181.236     -510.10028     -510.10028    
      3000  -13146.553     -13146.553     -13279.116     -13279.116      256.45056      256.45056      67126.941      67126.941      261.30471      261.30471    
Loop time of 410.224 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.951 hours/ns, 2.438 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    | 409.29     | 409.29     | 409.29     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1476     | 0.1476     | 0.1476     |   0.0 |  0.04
Output  | 0.00022671 | 0.00022671 | 0.00022671 |   0.0 |  0.00
Modify  | 0.68461    | 0.68461    | 0.68461    |   0.0 |  0.17
Other   |            | 0.09866    |            |       |  0.02

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

Total # of neighbors = 323246
Ave neighs/atom = 80.8115
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13146.553     -13146.553     -13279.116     -13279.116      256.45056      256.45056      67126.941      67126.941      261.30471      261.30471    
      4000  -13148.988     -13148.988     -13282.982     -13282.982      259.22074      259.22074      67136.744      67136.744      6.8408406      6.8408406    
Loop time of 413.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.724 hours/ns, 2.421 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    | 412.07     | 412.07     | 412.07     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14812    | 0.14812    | 0.14812    |   0.0 |  0.04
Output  | 0.00034025 | 0.00034025 | 0.00034025 |   0.0 |  0.00
Modify  | 0.69363    | 0.69363    | 0.69363    |   0.0 |  0.17
Other   |            | 0.09905    |            |       |  0.02

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

Total # of neighbors = 323310
Ave neighs/atom = 80.8275
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13148.988     -13148.988     -13282.982     -13282.982      259.22074      259.22074      67136.744      67136.744      6.8408406      6.8408406    
      5000  -13149.61      -13149.61      -13280.066     -13280.066      252.37756      252.37756      67175.99       67175.99      -392.19142     -392.19142    
Loop time of 411.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.392 hours/ns, 2.428 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    | 410.87     | 410.87     | 410.87     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1481     | 0.1481     | 0.1481     |   0.0 |  0.04
Output  | 0.00019089 | 0.00019089 | 0.00019089 |   0.0 |  0.00
Modify  | 0.69573    | 0.69573    | 0.69573    |   0.0 |  0.17
Other   |            | 0.0995     |            |       |  0.02

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

Total # of neighbors = 323512
Ave neighs/atom = 80.878
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 = 254.341572847492, Press = 152.899724085923
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13149.61      -13149.61      -13280.066     -13280.066      252.37756      252.37756      67175.99       67175.99      -392.19142     -392.19142    
      6000  -13146.493     -13146.493     -13275.066     -13275.066      248.73342      248.73342      67149.082      67149.082      116.75537      116.75537    
Loop time of 408.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.588 hours/ns, 2.445 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    | 407.96     | 407.96     | 407.96     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14791    | 0.14791    | 0.14791    |   0.0 |  0.04
Output  | 0.00018806 | 0.00018806 | 0.00018806 |   0.0 |  0.00
Modify  | 0.71097    | 0.71097    | 0.71097    |   0.0 |  0.17
Other   |            | 0.09838    |            |       |  0.02

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

Total # of neighbors = 323360
Ave neighs/atom = 80.84
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.598498690719, Press = -15.0449800003574
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13146.493     -13146.493     -13275.066     -13275.066      248.73342      248.73342      67149.082      67149.082      116.75537      116.75537    
      7000  -13151.395     -13151.395     -13280.774     -13280.774      250.29306      250.29306      67043.737      67043.737      1076.1613      1076.1613    
Loop time of 408.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.511 hours/ns, 2.447 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    | 407.68     | 407.68     | 407.68     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14671    | 0.14671    | 0.14671    |   0.0 |  0.04
Output  | 0.00026434 | 0.00026434 | 0.00026434 |   0.0 |  0.00
Modify  | 0.70889    | 0.70889    | 0.70889    |   0.0 |  0.17
Other   |            | 0.09912    |            |       |  0.02

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

Total # of neighbors = 323594
Ave neighs/atom = 80.8985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.051922984366, Press = 13.3582463766549
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13151.395     -13151.395     -13280.774     -13280.774      250.29306      250.29306      67043.737      67043.737      1076.1613      1076.1613    
      8000  -13146.964     -13146.964     -13279.842     -13279.842      257.06221      257.06221      67224.03       67224.03      -893.20355     -893.20355    
Loop time of 408.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.576 hours/ns, 2.446 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    | 407.92     | 407.92     | 407.92     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14722    | 0.14722    | 0.14722    |   0.0 |  0.04
Output  | 0.00018849 | 0.00018849 | 0.00018849 |   0.0 |  0.00
Modify  | 0.70991    | 0.70991    | 0.70991    |   0.0 |  0.17
Other   |            | 0.09875    |            |       |  0.02

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

Total # of neighbors = 323746
Ave neighs/atom = 80.9365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.084489788654, Press = 9.59729237034165
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13146.964     -13146.964     -13279.842     -13279.842      257.06221      257.06221      67224.03       67224.03      -893.20355     -893.20355    
      9000  -13146.656     -13146.656     -13279.082     -13279.082      256.18825      256.18825      67160.773      67160.773     -147.05245     -147.05245    
Loop time of 409.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.612 hours/ns, 2.445 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    | 408.05     | 408.05     | 408.05     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14624    | 0.14624    | 0.14624    |   0.0 |  0.04
Output  | 0.00024534 | 0.00024534 | 0.00024534 |   0.0 |  0.00
Modify  | 0.70642    | 0.70642    | 0.70642    |   0.0 |  0.17
Other   |            | 0.09798    |            |       |  0.02

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

Total # of neighbors = 323002
Ave neighs/atom = 80.7505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.021019295059, Press = -0.471051993539119
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13146.656     -13146.656     -13279.082     -13279.082      256.18825      256.18825      67160.773      67160.773     -147.05245     -147.05245    
     10000  -13150.613     -13150.613     -13280.634     -13280.634      251.53592      251.53592      67127.496      67127.496      134.14432      134.14432    
Loop time of 408.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.425 hours/ns, 2.449 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    | 407.37     | 407.37     | 407.37     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1473     | 0.1473     | 0.1473     |   0.0 |  0.04
Output  | 0.00019088 | 0.00019088 | 0.00019088 |   0.0 |  0.00
Modify  | 0.71274    | 0.71274    | 0.71274    |   0.0 |  0.17
Other   |            | 0.09871    |            |       |  0.02

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

Total # of neighbors = 323636
Ave neighs/atom = 80.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.333749605007, Press = 2.08983916026858
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13150.613     -13150.613     -13280.634     -13280.634      251.53592      251.53592      67127.496      67127.496      134.14432      134.14432    
     11000  -13148.508     -13148.508     -13277.568     -13277.568      249.67585      249.67585      67151.745      67151.745     -38.733322     -38.733322    
Loop time of 410.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.063 hours/ns, 2.435 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    | 409.67     | 409.67     | 409.67     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14671    | 0.14671    | 0.14671    |   0.0 |  0.04
Output  | 0.0001893  | 0.0001893  | 0.0001893  |   0.0 |  0.00
Modify  | 0.71258    | 0.71258    | 0.71258    |   0.0 |  0.17
Other   |            | 0.09876    |            |       |  0.02

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

Total # of neighbors = 323476
Ave neighs/atom = 80.869
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.241118566681, Press = 1.64202862405918
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13148.508     -13148.508     -13277.568     -13277.568      249.67585      249.67585      67151.745      67151.745     -38.733322     -38.733322    
     12000  -13150.525     -13150.525     -13280.298     -13280.298      251.05444      251.05444      67133.416      67133.416      86.194674      86.194674    
Loop time of 412.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.656 hours/ns, 2.423 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    | 411.79     | 411.79     | 411.79     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14958    | 0.14958    | 0.14958    |   0.0 |  0.04
Output  | 0.00019085 | 0.00019085 | 0.00019085 |   0.0 |  0.00
Modify  | 0.72073    | 0.72073    | 0.72073    |   0.0 |  0.17
Other   |            | 0.09881    |            |       |  0.02

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

Total # of neighbors = 323274
Ave neighs/atom = 80.8185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.239077856863, Press = 0.508348550746471
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13150.525     -13150.525     -13280.298     -13280.298      251.05444      251.05444      67133.416      67133.416      86.194674      86.194674    
     13000  -13147.055     -13147.055     -13278.398     -13278.398      254.09128      254.09128      67141.012      67141.012      120.7139       120.7139     
Loop time of 410.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.911 hours/ns, 2.439 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    | 409.12     | 409.12     | 409.12     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1473     | 0.1473     | 0.1473     |   0.0 |  0.04
Output  | 0.00018692 | 0.00018692 | 0.00018692 |   0.0 |  0.00
Modify  | 0.71045    | 0.71045    | 0.71045    |   0.0 |  0.17
Other   |            | 0.09885    |            |       |  0.02

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

Total # of neighbors = 323396
Ave neighs/atom = 80.849
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.323622719184, Press = 2.37312042377303
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13147.055     -13147.055     -13278.398     -13278.398      254.09128      254.09128      67141.012      67141.012      120.7139       120.7139     
     14000  -13150.075     -13150.075     -13281.005     -13281.005      253.29308      253.29308      67193.945      67193.945     -655.16884     -655.16884    
Loop time of 409.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.825 hours/ns, 2.440 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    | 408.81     | 408.81     | 408.81     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14895    | 0.14895    | 0.14895    |   0.0 |  0.04
Output  | 0.00060325 | 0.00060325 | 0.00060325 |   0.0 |  0.00
Modify  | 0.7132     | 0.7132     | 0.7132     |   0.0 |  0.17
Other   |            | 0.09858    |            |       |  0.02

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

Total # of neighbors = 323420
Ave neighs/atom = 80.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.401070456461, Press = 0.477388352808377
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13150.075     -13150.075     -13281.005     -13281.005      253.29308      253.29308      67193.945      67193.945     -655.16884     -655.16884    
     15000  -13146.915     -13146.915     -13280.072     -13280.072      257.60153      257.60153      67109.312      67109.312      420.09946      420.09946    
Loop time of 409.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.813 hours/ns, 2.441 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    | 408.76     | 408.76     | 408.76     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14775    | 0.14775    | 0.14775    |   0.0 |  0.04
Output  | 0.00024032 | 0.00024032 | 0.00024032 |   0.0 |  0.00
Modify  | 0.71459    | 0.71459    | 0.71459    |   0.0 |  0.17
Other   |            | 0.09884    |            |       |  0.02

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

Total # of neighbors = 323252
Ave neighs/atom = 80.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.50301678578, Press = -1.74102701038354
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13146.915     -13146.915     -13280.072     -13280.072      257.60153      257.60153      67109.312      67109.312      420.09946      420.09946    
     16000  -13148.475     -13148.475     -13278.506     -13278.506      251.55367      251.55367      67074.918      67074.918      842.97951      842.97951    
Loop time of 411.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.424 hours/ns, 2.428 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    | 410.96     | 410.96     | 410.96     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14789    | 0.14789    | 0.14789    |   0.0 |  0.04
Output  | 0.00019014 | 0.00019014 | 0.00019014 |   0.0 |  0.00
Modify  | 0.71713    | 0.71713    | 0.71713    |   0.0 |  0.17
Other   |            | 0.09947    |            |       |  0.02

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

Total # of neighbors = 323538
Ave neighs/atom = 80.8845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.468885658992, Press = 3.75517112961757
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13148.475     -13148.475     -13278.506     -13278.506      251.55367      251.55367      67074.918      67074.918      842.97951      842.97951    
     17000  -13153.799     -13153.799     -13281.621     -13281.621      247.28195      247.28195      67224.211      67224.211     -1064.926      -1064.926     
Loop time of 410.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.905 hours/ns, 2.439 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    | 409.1      | 409.1      | 409.1      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14645    | 0.14645    | 0.14645    |   0.0 |  0.04
Output  | 0.00024457 | 0.00024457 | 0.00024457 |   0.0 |  0.00
Modify  | 0.71624    | 0.71624    | 0.71624    |   0.0 |  0.17
Other   |            | 0.09878    |            |       |  0.02

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

Total # of neighbors = 323766
Ave neighs/atom = 80.9415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.418081512643, Press = 1.05864011695874
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13153.799     -13153.799     -13281.621     -13281.621      247.28195      247.28195      67224.211      67224.211     -1064.926      -1064.926     
     18000  -13148.105     -13148.105     -13279.644     -13279.644      254.47134      254.47134      67131.751      67131.751      149.30933      149.30933    
Loop time of 411.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.320 hours/ns, 2.430 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    | 410.59     | 410.59     | 410.59     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14696    | 0.14696    | 0.14696    |   0.0 |  0.04
Output  | 0.00023884 | 0.00023884 | 0.00023884 |   0.0 |  0.00
Modify  | 0.71509    | 0.71509    | 0.71509    |   0.0 |  0.17
Other   |            | 0.09924    |            |       |  0.02

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

Total # of neighbors = 323098
Ave neighs/atom = 80.7745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.271462044447, Press = -0.466144592844669
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13148.105     -13148.105     -13279.644     -13279.644      254.47134      254.47134      67131.751      67131.751      149.30933      149.30933    
     19000  -13149.71      -13149.71      -13278.106     -13278.106      248.39061      248.39061      67120.083      67120.083      283.64497      283.64497    
Loop time of 413.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.930 hours/ns, 2.417 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    | 412.78     | 412.78     | 412.78     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14784    | 0.14784    | 0.14784    |   0.0 |  0.04
Output  | 0.00018835 | 0.00018835 | 0.00018835 |   0.0 |  0.00
Modify  | 0.7179     | 0.7179     | 0.7179     |   0.0 |  0.17
Other   |            | 0.09954    |            |       |  0.02

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

Total # of neighbors = 323482
Ave neighs/atom = 80.8705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.251392987366, Press = 1.18533756692831
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13149.71      -13149.71      -13278.106     -13278.106      248.39061      248.39061      67120.083      67120.083      283.64497      283.64497    
     20000  -13147.417     -13147.417     -13278.639     -13278.639      253.85815      253.85815      67181.246      67181.246     -363.0167      -363.0167     
Loop time of 411.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.328 hours/ns, 2.430 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    | 410.61     | 410.61     | 410.61     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14776    | 0.14776    | 0.14776    |   0.0 |  0.04
Output  | 0.00026711 | 0.00026711 | 0.00026711 |   0.0 |  0.00
Modify  | 0.72002    | 0.72002    | 0.72002    |   0.0 |  0.17
Other   |            | 0.09917    |            |       |  0.02

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

Total # of neighbors = 323456
Ave neighs/atom = 80.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.273601911475, Press = 0.777362420798588
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13147.417     -13147.417     -13278.639     -13278.639      253.85815      253.85815      67181.246      67181.246     -363.0167      -363.0167     
     21000  -13147.412     -13147.412     -13280.579     -13280.579      257.62229      257.62229      67133.535      67133.535      123.39647      123.39647    
Loop time of 408.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.528 hours/ns, 2.447 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    | 407.75     | 407.75     | 407.75     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14696    | 0.14696    | 0.14696    |   0.0 |  0.04
Output  | 0.00018739 | 0.00018739 | 0.00018739 |   0.0 |  0.00
Modify  | 0.70837    | 0.70837    | 0.70837    |   0.0 |  0.17
Other   |            | 0.09757    |            |       |  0.02

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

Total # of neighbors = 323478
Ave neighs/atom = 80.8695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.283207165182, Press = -1.01846633324198
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13147.412     -13147.412     -13280.579     -13280.579      257.62229      257.62229      67133.535      67133.535      123.39647      123.39647    
     22000  -13152.837     -13152.837     -13283.168     -13283.168      252.13337      252.13337      67044.193      67044.193      986.54021      986.54021    
Loop time of 415.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.298 hours/ns, 2.409 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    | 414.1      | 414.1      | 414.1      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.04
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.72401    | 0.72401    | 0.72401    |   0.0 |  0.17
Other   |            | 0.09972    |            |       |  0.02

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

Total # of neighbors = 323408
Ave neighs/atom = 80.852
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.216865755285, Press = 2.23001515231864
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13152.837     -13152.837     -13283.168     -13283.168      252.13337      252.13337      67044.193      67044.193      986.54021      986.54021    
     23000  -13147.548     -13147.548     -13277.871     -13277.871      252.11831      252.11831      67231.533      67231.533     -923.48905     -923.48905    
Loop time of 415.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.511 hours/ns, 2.405 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 414.86     | 414.86     | 414.86     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1492     | 0.1492     | 0.1492     |   0.0 |  0.04
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.72822    | 0.72822    | 0.72822    |   0.0 |  0.18
Other   |            | 0.1004     |            |       |  0.02

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

Total # of neighbors = 323808
Ave neighs/atom = 80.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.170470723347, Press = 1.02152579928463
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13147.548     -13147.548     -13277.871     -13277.871      252.11831      252.11831      67231.533      67231.533     -923.48905     -923.48905    
     24000  -13151.638     -13151.638     -13281.4       -13281.4        251.03293      251.03293      67132.88       67132.88       38.486138      38.486138    
Loop time of 410.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.028 hours/ns, 2.436 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    | 409.53     | 409.53     | 409.53     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14763    | 0.14763    | 0.14763    |   0.0 |  0.04
Output  | 0.00018891 | 0.00018891 | 0.00018891 |   0.0 |  0.00
Modify  | 0.71972    | 0.71972    | 0.71972    |   0.0 |  0.18
Other   |            | 0.09991    |            |       |  0.02

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

Total # of neighbors = 323296
Ave neighs/atom = 80.824
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.097092093491, Press = -0.679929619002428
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13151.638     -13151.638     -13281.4       -13281.4        251.03293      251.03293      67132.88       67132.88       38.486138      38.486138    
     25000  -13146.806     -13146.806     -13277.375     -13277.375      252.59385      252.59385      67095.113      67095.113      676.72038      676.72038    
Loop time of 412.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.531 hours/ns, 2.425 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    | 411.35     | 411.35     | 411.35     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.04
Output  | 0.00018885 | 0.00018885 | 0.00018885 |   0.0 |  0.00
Modify  | 0.71337    | 0.71337    | 0.71337    |   0.0 |  0.17
Other   |            | 0.09935    |            |       |  0.02

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

Total # of neighbors = 323546
Ave neighs/atom = 80.8865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.046040030236, Press = 0.921153336548488
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13146.806     -13146.806     -13277.375     -13277.375      252.59385      252.59385      67095.113      67095.113      676.72038      676.72038    
     26000  -13147.275     -13147.275     -13279.767     -13279.767      256.31458      256.31458      67184.057      67184.057     -463.64544     -463.64544    
Loop time of 410.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.105 hours/ns, 2.434 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    | 409.82     | 409.82     | 409.82     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14716    | 0.14716    | 0.14716    |   0.0 |  0.04
Output  | 0.00024334 | 0.00024334 | 0.00024334 |   0.0 |  0.00
Modify  | 0.71568    | 0.71568    | 0.71568    |   0.0 |  0.17
Other   |            | 0.09948    |            |       |  0.02

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

Total # of neighbors = 323562
Ave neighs/atom = 80.8905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.036235913862, Press = 0.84444091105509
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13147.275     -13147.275     -13279.767     -13279.767      256.31458      256.31458      67184.057      67184.057     -463.64544     -463.64544    
     27000  -13146.644     -13146.644     -13279.419     -13279.419      256.86207      256.86207      67155.45       67155.45      -95.266339     -95.266339    
Loop time of 416.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.680 hours/ns, 2.401 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    | 415.47     | 415.47     | 415.47     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14931    | 0.14931    | 0.14931    |   0.0 |  0.04
Output  | 0.00023172 | 0.00023172 | 0.00023172 |   0.0 |  0.00
Modify  | 0.72526    | 0.72526    | 0.72526    |   0.0 |  0.17
Other   |            | 0.1002     |            |       |  0.02

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

Total # of neighbors = 323358
Ave neighs/atom = 80.8395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
67144.0265031351

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0