# 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.049998879432679*${_u_distance}
variable latticeconst_converted equal 4.049998879432679*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04999887943268
Lattice spacing in x,y,z = 4.0499989 4.0499989 4.0499989
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.499989 40.499989 40.499989)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.499989 40.499989 40.499989)
  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_PascuetFernandez_2015_Al__MO_315820974149_001
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.0698596988    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0698596988/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0698596988/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0698596988/(1*1*${_u_distance})
variable      V0_metal equal 66430.0698596988/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66430.0698596988*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0698596988 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_315820974149_001#item-citation

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

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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13298.766   -13298.766    -13439.96    -13439.96       273.15       273.15     66430.07     66430.07    2270.2437    2270.2437 
    1000    -13136.16    -13136.16   -13284.835   -13284.835    287.62262    287.62262     67854.79     67854.79    317.47967    317.47967 
Loop time of 197.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.856 hours/ns, 5.064 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.55     | 196.55     | 196.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15107    | 0.15107    | 0.15107    |   0.0 |  0.08
Output  | 0.00022319 | 0.00022319 | 0.00022319 |   0.0 |  0.00
Modify  | 0.68075    | 0.68075    | 0.68075    |   0.0 |  0.34
Other   |            | 0.1013     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
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
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -13136.16    -13136.16   -13284.835   -13284.835    287.62262    287.62262     67854.79     67854.79    317.47967    317.47967 
    2000   -13153.416   -13153.416   -13290.699   -13290.699    265.58259    265.58259    67826.554    67826.554    -135.2825    -135.2825 
Loop time of 199.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.418 hours/ns, 5.012 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.56     | 198.56     | 198.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15122    | 0.15122    | 0.15122    |   0.0 |  0.08
Output  | 0.0002152  | 0.0002152  | 0.0002152  |   0.0 |  0.00
Modify  | 0.6906     | 0.6906     | 0.6906     |   0.0 |  0.35
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320728.0 ave      320728 max      320728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320728
Ave neighs/atom = 80.182000
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
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13153.416   -13153.416   -13290.699   -13290.699    265.58259    265.58259    67826.554    67826.554    -135.2825    -135.2825 
    3000   -13144.875   -13144.875   -13290.175   -13290.175    281.09166    281.09166    67826.347    67826.347     48.75901     48.75901 
Loop time of 201.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.913 hours/ns, 4.968 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.33     | 200.33     | 200.33     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.08
Output  | 0.00021704 | 0.00021704 | 0.00021704 |   0.0 |  0.00
Modify  | 0.70061    | 0.70061    | 0.70061    |   0.0 |  0.35
Other   |            | 0.1018     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320628.0 ave      320628 max      320628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320628
Ave neighs/atom = 80.157000
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
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13144.875   -13144.875   -13290.175   -13290.175    281.09166    281.09166    67826.347    67826.347     48.75901     48.75901 
    4000   -13150.488   -13150.488   -13290.912   -13290.912    271.66076    271.66076    67829.156    67829.156   -144.59724   -144.59724 
Loop time of 202.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.278 hours/ns, 4.936 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.64     | 201.64     | 201.64     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15355    | 0.15355    | 0.15355    |   0.0 |  0.08
Output  | 0.00024646 | 0.00024646 | 0.00024646 |   0.0 |  0.00
Modify  | 0.70497    | 0.70497    | 0.70497    |   0.0 |  0.35
Other   |            | 0.102      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320814.0 ave      320814 max      320814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320814
Ave neighs/atom = 80.203500
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
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13150.488   -13150.488   -13290.912   -13290.912    271.66076    271.66076    67829.156    67829.156   -144.59724   -144.59724 
    5000   -13145.046   -13145.046   -13289.508   -13289.508    279.47144    279.47144    67884.697    67884.697   -476.25502   -476.25502 
Loop time of 200.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.581 hours/ns, 4.998 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.15     | 199.15     | 199.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14956    | 0.14956    | 0.14956    |   0.0 |  0.07
Output  | 0.00017756 | 0.00017756 | 0.00017756 |   0.0 |  0.00
Modify  | 0.6911     | 0.6911     | 0.6911     |   0.0 |  0.35
Other   |            | 0.1012     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320688.0 ave      320688 max      320688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320688
Ave neighs/atom = 80.172000
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 = 276.374523831649, Press = 64.873598434585
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13145.046   -13145.046   -13289.508   -13289.508    279.47144    279.47144    67884.697    67884.697   -476.25502   -476.25502 
    6000   -13149.467   -13149.467   -13288.993   -13288.993    269.92313    269.92313    67749.375    67749.375    826.51264    826.51264 
Loop time of 203.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.508 hours/ns, 4.916 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    | 202.44     | 202.44     | 202.44     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15364    | 0.15364    | 0.15364    |   0.0 |  0.08
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.72909    | 0.72909    | 0.72909    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320550.0 ave      320550 max      320550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320550
Ave neighs/atom = 80.137500
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.909976332228, Press = 35.6339242579271
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13149.467   -13149.467   -13288.993   -13288.993    269.92313    269.92313    67749.375    67749.375    826.51264    826.51264 
    7000   -13146.454   -13146.454   -13288.289   -13288.289    274.38789    274.38789    67692.389    67692.389    1540.9239    1540.9239 
Loop time of 202.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.172 hours/ns, 4.945 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.24     | 201.24     | 201.24     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15339    | 0.15339    | 0.15339    |   0.0 |  0.08
Output  | 0.00017825 | 0.00017825 | 0.00017825 |   0.0 |  0.00
Modify  | 0.72527    | 0.72527    | 0.72527    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320898.0 ave      320898 max      320898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320898
Ave neighs/atom = 80.224500
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.305660341267, Press = -9.6216326872851
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13146.454   -13146.454   -13288.289   -13288.289    274.38789    274.38789    67692.389    67692.389    1540.9239    1540.9239 
    8000   -13147.502   -13147.502   -13288.949   -13288.949     273.6396     273.6396    67870.585    67870.585   -336.55215   -336.55215 
Loop time of 199.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.518 hours/ns, 5.003 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.91     | 198.91     | 198.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15086    | 0.15086    | 0.15086    |   0.0 |  0.08
Output  | 0.00022809 | 0.00022809 | 0.00022809 |   0.0 |  0.00
Modify  | 0.7071     | 0.7071     | 0.7071     |   0.0 |  0.35
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      321258.0 ave      321258 max      321258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321258
Ave neighs/atom = 80.314500
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.112930275016, Press = -6.30331924566138
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13147.502   -13147.502   -13288.949   -13288.949     273.6396     273.6396    67870.585    67870.585   -336.55215   -336.55215 
    9000   -13147.064   -13147.064   -13288.437   -13288.437    273.49591    273.49591    67896.634    67896.634   -539.96724   -539.96724 
Loop time of 201.504 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.973 hours/ns, 4.963 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.53     | 200.53     | 200.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15332    | 0.15332    | 0.15332    |   0.0 |  0.08
Output  | 0.00017742 | 0.00017742 | 0.00017742 |   0.0 |  0.00
Modify  | 0.719      | 0.719      | 0.719      |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320686.0 ave      320686 max      320686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320686
Ave neighs/atom = 80.171500
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.897081170013, Press = 2.4327277339825
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13147.064   -13147.064   -13288.437   -13288.437    273.49591    273.49591    67896.634    67896.634   -539.96724   -539.96724 
   10000   -13157.572   -13157.572   -13295.118   -13295.118    266.09124    266.09124    67767.647    67767.647    102.40541    102.40541 
Loop time of 200 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.556 hours/ns, 5.000 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.04     | 199.04     | 199.04     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15095    | 0.15095    | 0.15095    |   0.0 |  0.08
Output  | 0.00025076 | 0.00025076 | 0.00025076 |   0.0 |  0.00
Modify  | 0.70971    | 0.70971    | 0.70971    |   0.0 |  0.35
Other   |            | 0.0995     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320746.0 ave      320746 max      320746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320746
Ave neighs/atom = 80.186500
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.722897640147, Press = 3.26685684013312
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13157.572   -13157.572   -13295.118   -13295.118    266.09124    266.09124    67767.647    67767.647    102.40541    102.40541 
   11000   -13147.883   -13147.883   -13287.951   -13287.951    270.97025    270.97025    67784.436    67784.436    542.72848    542.72848 
Loop time of 200.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.630 hours/ns, 4.993 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.31     | 199.31     | 199.31     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1507     | 0.1507     | 0.1507     |   0.0 |  0.08
Output  | 0.00017729 | 0.00017729 | 0.00017729 |   0.0 |  0.00
Modify  | 0.71239    | 0.71239    | 0.71239    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320874.0 ave      320874 max      320874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320874
Ave neighs/atom = 80.218500
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.499895570897, Press = 0.394342437135959
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13147.883   -13147.883   -13287.951   -13287.951    270.97025    270.97025    67784.436    67784.436    542.72848    542.72848 
   12000   -13150.038   -13150.038   -13289.447   -13289.447    269.69641    269.69641    67847.013    67847.013   -187.92196   -187.92196 
Loop time of 198.75 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.208 hours/ns, 5.031 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.8      | 197.8      | 197.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15058    | 0.15058    | 0.15058    |   0.0 |  0.08
Output  | 0.00022464 | 0.00022464 | 0.00022464 |   0.0 |  0.00
Modify  | 0.70338    | 0.70338    | 0.70338    |   0.0 |  0.35
Other   |            | 0.09963    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      321026.0 ave      321026 max      321026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321026
Ave neighs/atom = 80.256500
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.55396607588, Press = -3.44285382328193
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13150.038   -13150.038   -13289.447   -13289.447    269.69641    269.69641    67847.013    67847.013   -187.92196   -187.92196 
   13000   -13148.703   -13148.703   -13288.363   -13288.363    270.18125    270.18125     67962.07     67962.07     -1181.85     -1181.85 
Loop time of 199.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.288 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.07     | 198.07     | 198.07     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15179    | 0.15179    | 0.15179    |   0.0 |  0.08
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.71299    | 0.71299    | 0.71299    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320944.0 ave      320944 max      320944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320944
Ave neighs/atom = 80.236000
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.605224825162, Press = 2.9182892909099
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13148.703   -13148.703   -13288.363   -13288.363    270.18125    270.18125     67962.07     67962.07     -1181.85     -1181.85 
   14000   -13152.673   -13152.673    -13294.12    -13294.12    273.63948    273.63948    67743.548    67743.548    534.42827    534.42827 
Loop time of 196.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.545 hours/ns, 5.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.41     | 195.41     | 195.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14961    | 0.14961    | 0.14961    |   0.0 |  0.08
Output  | 0.00022799 | 0.00022799 | 0.00022799 |   0.0 |  0.00
Modify  | 0.69802    | 0.69802    | 0.69802    |   0.0 |  0.36
Other   |            | 0.0995     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320416.0 ave      320416 max      320416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320416
Ave neighs/atom = 80.104000
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.663425498434, Press = 4.93071538155369
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13152.673   -13152.673    -13294.12    -13294.12    273.63948    273.63948    67743.548    67743.548    534.42827    534.42827 
   15000   -13146.573   -13146.573   -13293.022   -13293.022    283.31613    283.31613    67772.908    67772.908    411.32675    411.32675 
Loop time of 196.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.667 hours/ns, 5.081 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    | 195.86     | 195.86     | 195.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14848    | 0.14848    | 0.14848    |   0.0 |  0.08
Output  | 0.00018018 | 0.00018018 | 0.00018018 |   0.0 |  0.00
Modify  | 0.69801    | 0.69801    | 0.69801    |   0.0 |  0.35
Other   |            | 0.09987    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320976.0 ave      320976 max      320976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320976
Ave neighs/atom = 80.244000
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.606028573532, Press = -1.22119096881489
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13146.573   -13146.573   -13293.022   -13293.022    283.31613    283.31613    67772.908    67772.908    411.32675    411.32675 
   16000   -13148.718   -13148.718   -13287.518   -13287.518    268.51828    268.51828    67848.216    67848.216    10.196798    10.196798 
Loop time of 198.306 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.085 hours/ns, 5.043 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.35     | 197.35     | 197.35     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14939    | 0.14939    | 0.14939    |   0.0 |  0.08
Output  | 0.00022263 | 0.00022263 | 0.00022263 |   0.0 |  0.00
Modify  | 0.7057     | 0.7057     | 0.7057     |   0.0 |  0.36
Other   |            | 0.0998     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      321048.0 ave      321048 max      321048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321048
Ave neighs/atom = 80.262000
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.697887124437, Press = -1.6012243569114
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13148.718   -13148.718   -13287.518   -13287.518    268.51828    268.51828    67848.216    67848.216    10.196798    10.196798 
   17000   -13146.162   -13146.162   -13286.988   -13286.988    272.43611    272.43611    67891.456    67891.456    -370.9208    -370.9208 
Loop time of 199.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.514 hours/ns, 5.004 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.89     | 198.89     | 198.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14917    | 0.14917    | 0.14917    |   0.0 |  0.07
Output  | 0.00017902 | 0.00017902 | 0.00017902 |   0.0 |  0.00
Modify  | 0.7121     | 0.7121     | 0.7121     |   0.0 |  0.36
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320706.0 ave      320706 max      320706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320706
Ave neighs/atom = 80.176500
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.829614992496, Press = 1.61972274581946
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13146.162   -13146.162   -13286.988   -13286.988    272.43611    272.43611    67891.456    67891.456    -370.9208    -370.9208 
   18000   -13148.171   -13148.171   -13291.436   -13291.436    277.15499    277.15499    67812.017    67812.017    91.393249    91.393249 
Loop time of 201.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.040 hours/ns, 4.957 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.76     | 200.76     | 200.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15373    | 0.15373    | 0.15373    |   0.0 |  0.08
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.72542    | 0.72542    | 0.72542    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320612.0 ave      320612 max      320612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320612
Ave neighs/atom = 80.153000
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.996177915224, Press = 1.97888308326373
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13148.171   -13148.171   -13291.436   -13291.436    277.15499    277.15499    67812.017    67812.017    91.393249    91.393249 
   19000    -13144.42    -13144.42   -13289.114   -13289.114    279.92052    279.92052    67708.562    67708.562    1337.2965    1337.2965 
Loop time of 198.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.169 hours/ns, 5.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.65     | 197.65     | 197.65     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15136    | 0.15136    | 0.15136    |   0.0 |  0.08
Output  | 0.0001759  | 0.0001759  | 0.0001759  |   0.0 |  0.00
Modify  | 0.7066     | 0.7066     | 0.7066     |   0.0 |  0.36
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320672.0 ave      320672 max      320672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320672
Ave neighs/atom = 80.168000
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.051995105525, Press = -0.295072960378129
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13144.42    -13144.42   -13289.114   -13289.114    279.92052    279.92052    67708.562    67708.562    1337.2965    1337.2965 
   20000   -13153.386   -13153.386   -13292.435   -13292.435    269.00066    269.00066    67841.499    67841.499   -396.62182   -396.62182 
Loop time of 197.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.762 hours/ns, 5.072 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.19     | 196.19     | 196.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15116    | 0.15116    | 0.15116    |   0.0 |  0.08
Output  | 0.00017618 | 0.00017618 | 0.00017618 |   0.0 |  0.00
Modify  | 0.69704    | 0.69704    | 0.69704    |   0.0 |  0.35
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      321210.0 ave      321210 max      321210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321210
Ave neighs/atom = 80.302500
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.053470047596, Press = -2.84943114146276
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13153.386   -13153.386   -13292.435   -13292.435    269.00066    269.00066    67841.499    67841.499   -396.62182   -396.62182 
   21000   -13148.169   -13148.169   -13290.071   -13290.071    274.51942    274.51942    67901.713    67901.713   -738.47235   -738.47235 
Loop time of 198.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.047 hours/ns, 5.046 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.22     | 197.22     | 197.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1485     | 0.1485     | 0.1485     |   0.0 |  0.07
Output  | 0.0001777  | 0.0001777  | 0.0001777  |   0.0 |  0.00
Modify  | 0.70292    | 0.70292    | 0.70292    |   0.0 |  0.35
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320732.0 ave      320732 max      320732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320732
Ave neighs/atom = 80.183000
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.939461625718, Press = 0.346907041924813
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13148.169   -13148.169   -13290.071   -13290.071    274.51942    274.51942    67901.713    67901.713   -738.47235   -738.47235 
   22000   -13147.271   -13147.271   -13285.895   -13285.895    268.17647    268.17647     67823.67     67823.67    336.41178    336.41178 
Loop time of 203.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.406 hours/ns, 4.925 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.08     | 202.08     | 202.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15422    | 0.15422    | 0.15422    |   0.0 |  0.08
Output  | 0.00017784 | 0.00017784 | 0.00017784 |   0.0 |  0.00
Modify  | 0.7318     | 0.7318     | 0.7318     |   0.0 |  0.36
Other   |            | 0.1019     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320336.0 ave      320336 max      320336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320336
Ave neighs/atom = 80.084000
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.940572445599, Press = 1.83511971799586
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13147.271   -13147.271   -13285.895   -13285.895    268.17647    268.17647     67823.67     67823.67    336.41178    336.41178 
   23000   -13151.059   -13151.059   -13291.496   -13291.496    271.68441    271.68441    67744.721    67744.721    735.12793    735.12793 
Loop time of 200.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.675 hours/ns, 4.989 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.46     | 199.46     | 199.46     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15138    | 0.15138    | 0.15138    |   0.0 |  0.08
Output  | 0.00017855 | 0.00017855 | 0.00017855 |   0.0 |  0.00
Modify  | 0.71921    | 0.71921    | 0.71921    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320856.0 ave      320856 max      320856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320856
Ave neighs/atom = 80.214000
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.825308322862, Press = -0.0402571190229165
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13151.059   -13151.059   -13291.496   -13291.496    271.68441    271.68441    67744.721    67744.721    735.12793    735.12793 
   24000   -13147.162   -13147.162   -13287.918   -13287.918    272.30209    272.30209    67838.501    67838.501    110.66392    110.66392 
Loop time of 197.854 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.959 hours/ns, 5.054 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.9      | 196.9      | 196.9      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14911    | 0.14911    | 0.14911    |   0.0 |  0.08
Output  | 0.00022144 | 0.00022144 | 0.00022144 |   0.0 |  0.00
Modify  | 0.70508    | 0.70508    | 0.70508    |   0.0 |  0.36
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      321008.0 ave      321008 max      321008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321008
Ave neighs/atom = 80.252000
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.887018507008, Press = -0.0718525602212952
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13147.162   -13147.162   -13287.918   -13287.918    272.30209    272.30209    67838.501    67838.501    110.66392    110.66392 
   25000   -13150.896   -13150.896   -13289.195   -13289.195    267.54819    267.54819    67809.035    67809.035    239.56016    239.56016 
Loop time of 199.612 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.448 hours/ns, 5.010 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.64     | 198.64     | 198.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15257    | 0.15257    | 0.15257    |   0.0 |  0.08
Output  | 0.00022939 | 0.00022939 | 0.00022939 |   0.0 |  0.00
Modify  | 0.7166     | 0.7166     | 0.7166     |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320682.0 ave      320682 max      320682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320682
Ave neighs/atom = 80.170500
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.941298771197, Press = 0.628851750588778
next a
jump SELF top
variable a loop 2000
run 1000
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.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13150.896   -13150.896   -13289.195   -13289.195    267.54819    267.54819    67809.035    67809.035    239.56016    239.56016 
   26000   -13147.987   -13147.987   -13290.474   -13290.474    275.65172    275.65172    67776.744    67776.744    463.80859    463.80859 
Loop time of 200.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.678 hours/ns, 4.989 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.47     | 199.47     | 199.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15237    | 0.15237    | 0.15237    |   0.0 |  0.08
Output  | 0.00043473 | 0.00043473 | 0.00043473 |   0.0 |  0.00
Modify  | 0.71562    | 0.71562    | 0.71562    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      320788.0 ave      320788 max      320788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320788
Ave neighs/atom = 80.197000
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
67834.2290490707

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0