# 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 2.863657340407371*${_u_distance}
variable latticeconst_converted equal 2.863657340407371*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365734040737
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
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 (28.636573 28.636573 28.636573)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.636573 28.636573 28.636573)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimShinLee_2009_FeMn__MO_058735400462_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5175609808 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_058735400462_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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8509.4205   -8509.4205        -8580        -8580       273.15       273.15    23483.518    23483.518    3210.2051    3210.2051 
    1000   -8435.9645   -8435.9645    -8504.112    -8504.112    263.73805    263.73805     23735.03     23735.03    -1633.172    -1633.172 
Loop time of 97.8759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.188 hours/ns, 10.217 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.381     | 97.381     | 97.381     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077195   | 0.077195   | 0.077195   |   0.0 |  0.08
Output  | 0.00020145 | 0.00020145 | 0.00020145 |   0.0 |  0.00
Modify  | 0.36026    | 0.36026    | 0.36026    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 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:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8435.9645   -8435.9645    -8504.112    -8504.112    263.73805    263.73805     23735.03     23735.03    -1633.172    -1633.172 
    2000   -8436.1934   -8436.1934   -8504.6273   -8504.6273    264.84645    264.84645    23705.147    23705.147    384.22124    384.22124 
Loop time of 98.6991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.416 hours/ns, 10.132 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    | 98.219     | 98.219     | 98.219     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074476   | 0.074476   | 0.074476   |   0.0 |  0.08
Output  | 0.00018601 | 0.00018601 | 0.00018601 |   0.0 |  0.00
Modify  | 0.34907    | 0.34907    | 0.34907    |   0.0 |  0.35
Other   |            | 0.05622    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116746.0 ave      116746 max      116746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116746
Ave neighs/atom = 58.373000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8436.1934   -8436.1934   -8504.6273   -8504.6273    264.84645    264.84645    23705.147    23705.147    384.22124    384.22124 
    3000   -8437.3673   -8437.3673   -8507.9353   -8507.9353    273.10558    273.10558     23699.07     23699.07    479.45669    479.45669 
Loop time of 99.2398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.567 hours/ns, 10.077 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    | 98.76      | 98.76      | 98.76      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074263   | 0.074263   | 0.074263   |   0.0 |  0.07
Output  | 0.00019132 | 0.00019132 | 0.00019132 |   0.0 |  0.00
Modify  | 0.34881    | 0.34881    | 0.34881    |   0.0 |  0.35
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116774.0 ave      116774 max      116774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8437.3673   -8437.3673   -8507.9353   -8507.9353    273.10558    273.10558     23699.07     23699.07    479.45669    479.45669 
    4000    -8434.763    -8434.763   -8504.8188   -8504.8188    271.12332    271.12332    23713.377    23713.377   -145.50203   -145.50203 
Loop time of 99.5546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.654 hours/ns, 10.045 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    | 99.07      | 99.07      | 99.07      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074857   | 0.074857   | 0.074857   |   0.0 |  0.08
Output  | 0.00018777 | 0.00018777 | 0.00018777 |   0.0 |  0.00
Modify  | 0.35255    | 0.35255    | 0.35255    |   0.0 |  0.35
Other   |            | 0.0573     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116664.0 ave      116664 max      116664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116664
Ave neighs/atom = 58.332000
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8434.763    -8434.763   -8504.8188   -8504.8188    271.12332    271.12332    23713.377    23713.377   -145.50203   -145.50203 
    5000   -8437.9706   -8437.9706   -8507.9334   -8507.9334    270.76324    270.76324    23696.466    23696.466    512.39743    512.39743 
Loop time of 99.7294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.703 hours/ns, 10.027 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.244     | 99.244     | 99.244     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074779   | 0.074779   | 0.074779   |   0.0 |  0.07
Output  | 0.00015232 | 0.00015232 | 0.00015232 |   0.0 |  0.00
Modify  | 0.35351    | 0.35351    | 0.35351    |   0.0 |  0.35
Other   |            | 0.05701    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 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:      116630.0 ave      116630 max      116630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116630
Ave neighs/atom = 58.315000
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 = 270.903036639528, Press = -148.386613491048
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8437.9706   -8437.9706   -8507.9334   -8507.9334    270.76324    270.76324    23696.466    23696.466    512.39743    512.39743 
    6000   -8435.9883   -8435.9883   -8504.2454   -8504.2454    264.16182    264.16182    23704.561    23704.561    623.51995    623.51995 
Loop time of 99.9366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.760 hours/ns, 10.006 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    | 99.434     | 99.434     | 99.434     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075094   | 0.075094   | 0.075094   |   0.0 |  0.08
Output  | 0.00018621 | 0.00018621 | 0.00018621 |   0.0 |  0.00
Modify  | 0.37026    | 0.37026    | 0.37026    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 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:      116646.0 ave      116646 max      116646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116646
Ave neighs/atom = 58.323000
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 = 271.713492975076, Press = -7.77804617762737
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8435.9883   -8435.9883   -8504.2454   -8504.2454    264.16182    264.16182    23704.561    23704.561    623.51995    623.51995 
    7000   -8436.2418   -8436.2418   -8507.9277   -8507.9277    277.43164    277.43164    23724.846    23724.846   -1279.2769   -1279.2769 
Loop time of 101.029 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.064 hours/ns, 9.898 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    | 100.52     | 100.52     | 100.52     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075301   | 0.075301   | 0.075301   |   0.0 |  0.07
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.37447    | 0.37447    | 0.37447    |   0.0 |  0.37
Other   |            | 0.05742    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 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:      116764.0 ave      116764 max      116764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116764
Ave neighs/atom = 58.382000
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.514931951178, Press = -16.2650539872518
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8436.2418   -8436.2418   -8507.9277   -8507.9277    277.43164    277.43164    23724.846    23724.846   -1279.2769   -1279.2769 
    8000   -8439.2681   -8439.2681    -8509.575    -8509.575    272.09486    272.09486    23678.145    23678.145    1661.9321    1661.9321 
Loop time of 100.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.947 hours/ns, 9.939 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    | 100.1      | 100.1      | 100.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075759   | 0.075759   | 0.075759   |   0.0 |  0.08
Output  | 0.00018864 | 0.00018864 | 0.00018864 |   0.0 |  0.00
Modify  | 0.37779    | 0.37779    | 0.37779    |   0.0 |  0.38
Other   |            | 0.05742    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116656.0 ave      116656 max      116656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116656
Ave neighs/atom = 58.328000
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.217028636993, Press = -7.89563512200885
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8439.2681   -8439.2681    -8509.575    -8509.575    272.09486    272.09486    23678.145    23678.145    1661.9321    1661.9321 
    9000   -8435.0973   -8435.0973   -8506.8513   -8506.8513     277.6956     277.6956    23724.641    23724.641   -1232.9202   -1232.9202 
Loop time of 100.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.806 hours/ns, 9.990 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    | 99.596     | 99.596     | 99.596     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075586   | 0.075586   | 0.075586   |   0.0 |  0.08
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.37393    | 0.37393    | 0.37393    |   0.0 |  0.37
Other   |            | 0.05714    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 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:      116608.0 ave      116608 max      116608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116608
Ave neighs/atom = 58.304000
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.291277385286, Press = 7.36406616094513
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8435.0973   -8435.0973   -8506.8513   -8506.8513     277.6956     277.6956    23724.641    23724.641   -1232.9202   -1232.9202 
   10000   -8433.4159   -8433.4159   -8502.8897   -8502.8897    268.87064    268.87064      23746.5      23746.5   -1996.5845   -1996.5845 
Loop time of 100.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.890 hours/ns, 9.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.903     | 99.903     | 99.903     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074199   | 0.074199   | 0.074199   |   0.0 |  0.07
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.37069    | 0.37069    | 0.37069    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2952.00 ave        2952 max        2952 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:      116638.0 ave      116638 max      116638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116638
Ave neighs/atom = 58.319000
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.504998265895, Press = -13.1321345581663
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8433.4159   -8433.4159   -8502.8897   -8502.8897    268.87064    268.87064      23746.5      23746.5   -1996.5845   -1996.5845 
   11000   -8436.6435   -8436.6435   -8506.2176   -8506.2176    269.25898    269.25898    23661.784    23661.784    3424.5152    3424.5152 
Loop time of 99.4535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.626 hours/ns, 10.055 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    | 98.952     | 98.952     | 98.952     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074673   | 0.074673   | 0.074673   |   0.0 |  0.08
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.36962    | 0.36962    | 0.36962    |   0.0 |  0.37
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116648.0 ave      116648 max      116648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116648
Ave neighs/atom = 58.324000
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.011463816393, Press = -6.95989627518031
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8436.6435   -8436.6435   -8506.2176   -8506.2176    269.25898    269.25898    23661.784    23661.784    3424.5152    3424.5152 
   12000   -8432.8693   -8432.8693   -8505.2379   -8505.2379    280.07395    280.07395    23715.753    23715.753   -101.88638   -101.88638 
Loop time of 99.3725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.603 hours/ns, 10.063 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    | 98.874     | 98.874     | 98.874     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074829   | 0.074829   | 0.074829   |   0.0 |  0.08
Output  | 0.0001859  | 0.0001859  | 0.0001859  |   0.0 |  0.00
Modify  | 0.36657    | 0.36657    | 0.36657    |   0.0 |  0.37
Other   |            | 0.05665    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 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:      116714.0 ave      116714 max      116714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116714
Ave neighs/atom = 58.357000
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.165871407718, Press = 4.11849724372039
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8432.8693   -8432.8693   -8505.2379   -8505.2379    280.07395    280.07395    23715.753    23715.753   -101.88638   -101.88638 
   13000   -8437.1875   -8437.1875   -8507.5322   -8507.5322    272.24095    272.24095    23717.547    23717.547   -856.88833   -856.88833 
Loop time of 99.9205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.756 hours/ns, 10.008 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    | 99.419     | 99.419     | 99.419     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074607   | 0.074607   | 0.074607   |   0.0 |  0.07
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.36983    | 0.36983    | 0.36983    |   0.0 |  0.37
Other   |            | 0.05698    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 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:      116622.0 ave      116622 max      116622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116622
Ave neighs/atom = 58.311000
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.353425207433, Press = -5.33234392585782
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8437.1875   -8437.1875   -8507.5322   -8507.5322    272.24095    272.24095    23717.547    23717.547   -856.88833   -856.88833 
   14000   -8435.1315   -8435.1315   -8505.1276   -8505.1276    270.89187    270.89187    23699.971    23699.971    1010.5086    1010.5086 
Loop time of 99.7301 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.703 hours/ns, 10.027 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.229     | 99.229     | 99.229     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074981   | 0.074981   | 0.074981   |   0.0 |  0.08
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.36934    | 0.36934    | 0.36934    |   0.0 |  0.37
Other   |            | 0.05665    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 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:      116574.0 ave      116574 max      116574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116574
Ave neighs/atom = 58.287000
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.287896522969, Press = -2.29708973928166
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8435.1315   -8435.1315   -8505.1276   -8505.1276    270.89187    270.89187    23699.971    23699.971    1010.5086    1010.5086 
   15000   -8438.2557   -8438.2557   -8508.1411   -8508.1411     270.4635     270.4635    23705.434    23705.434   -146.56683   -146.56683 
Loop time of 98.9134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.476 hours/ns, 10.110 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    | 98.419     | 98.419     | 98.419     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074366   | 0.074366   | 0.074366   |   0.0 |  0.08
Output  | 0.00040997 | 0.00040997 | 0.00040997 |   0.0 |  0.00
Modify  | 0.36302    | 0.36302    | 0.36302    |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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.225104446315, Press = 1.16268380369267
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8438.2557   -8438.2557   -8508.1411   -8508.1411     270.4635     270.4635    23705.434    23705.434   -146.56683   -146.56683 
   16000   -8436.1111   -8436.1111   -8506.9742   -8506.9742    274.24769    274.24769    23736.689    23736.689   -2106.3576   -2106.3576 
Loop time of 99.8283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.730 hours/ns, 10.017 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    | 99.323     | 99.323     | 99.323     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075287   | 0.075287   | 0.075287   |   0.0 |  0.08
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.37256    | 0.37256    | 0.37256    |   0.0 |  0.37
Other   |            | 0.05739    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 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:      116632.0 ave      116632 max      116632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116632
Ave neighs/atom = 58.316000
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.98218362361, Press = -6.4272529359209
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8436.1111   -8436.1111   -8506.9742   -8506.9742    274.24769    274.24769    23736.689    23736.689   -2106.3576   -2106.3576 
   17000   -8439.4415   -8439.4415    -8508.036    -8508.036    265.46787    265.46787     23660.57     23660.57    3154.5616    3154.5616 
Loop time of 99.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.577 hours/ns, 10.073 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    | 98.779     | 98.779     | 98.779     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074226   | 0.074226   | 0.074226   |   0.0 |  0.07
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.36626    | 0.36626    | 0.36626    |   0.0 |  0.37
Other   |            | 0.05684    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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.885464058712, Press = -3.36866226576651
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8439.4415   -8439.4415    -8508.036    -8508.036    265.46787    265.46787     23660.57     23660.57    3154.5616    3154.5616 
   18000   -8435.1307   -8435.1307   -8507.1204   -8507.1204    278.60747    278.60747    23714.894    23714.894    -458.7911    -458.7911 
Loop time of 99.3012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.584 hours/ns, 10.070 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    | 98.801     | 98.801     | 98.801     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074591   | 0.074591   | 0.074591   |   0.0 |  0.08
Output  | 0.00015599 | 0.00015599 | 0.00015599 |   0.0 |  0.00
Modify  | 0.36838    | 0.36838    | 0.36838    |   0.0 |  0.37
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116634.0 ave      116634 max      116634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116634
Ave neighs/atom = 58.317000
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.841163153664, Press = 3.5096364145665
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8435.1307   -8435.1307   -8507.1204   -8507.1204    278.60747    278.60747    23714.894    23714.894    -458.7911    -458.7911 
   19000    -8437.255    -8437.255   -8507.3118   -8507.3118    271.12696    271.12696     23729.01     23729.01    -1516.758    -1516.758 
Loop time of 98.9088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.475 hours/ns, 10.110 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    | 98.409     | 98.409     | 98.409     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074581   | 0.074581   | 0.074581   |   0.0 |  0.08
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.36808    | 0.36808    | 0.36808    |   0.0 |  0.37
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2966.00 ave        2966 max        2966 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:      116610.0 ave      116610 max      116610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116610
Ave neighs/atom = 58.305000
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.843101666268, Press = -2.8575473725628
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -8437.255    -8437.255   -8507.3118   -8507.3118    271.12696    271.12696     23729.01     23729.01    -1516.758    -1516.758 
   20000   -8435.8288   -8435.8288   -8506.5737   -8506.5737     273.7902     273.7902    23697.336    23697.336    935.89915    935.89915 
Loop time of 99.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.626 hours/ns, 10.055 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    | 98.954     | 98.954     | 98.954     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074662   | 0.074662   | 0.074662   |   0.0 |  0.08
Output  | 0.00019221 | 0.00019221 | 0.00019221 |   0.0 |  0.00
Modify  | 0.36894    | 0.36894    | 0.36894    |   0.0 |  0.37
Other   |            | 0.05658    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 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:      116608.0 ave      116608 max      116608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116608
Ave neighs/atom = 58.304000
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.81802521273, Press = -1.95283590289033
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8435.8288   -8435.8288   -8506.5737   -8506.5737     273.7902     273.7902    23697.336    23697.336    935.89915    935.89915 
   21000    -8440.169    -8440.169   -8508.0795   -8508.0795    262.82043    262.82043    23697.258    23697.258    413.52615    413.52615 
Loop time of 98.3428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.317 hours/ns, 10.169 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    | 97.847     | 97.847     | 97.847     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073918   | 0.073918   | 0.073918   |   0.0 |  0.08
Output  | 0.00017333 | 0.00017333 | 0.00017333 |   0.0 |  0.00
Modify  | 0.36431    | 0.36431    | 0.36431    |   0.0 |  0.37
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 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:      116648.0 ave      116648 max      116648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116648
Ave neighs/atom = 58.324000
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.749294943329, Press = -0.607094298703723
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -8440.169    -8440.169   -8508.0795   -8508.0795    262.82043    262.82043    23697.258    23697.258    413.52615    413.52615 
   22000   -8435.6755   -8435.6755   -8506.6933   -8506.6933    274.84594    274.84594    23713.229    23713.229   -242.85043   -242.85043 
Loop time of 98.6978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.416 hours/ns, 10.132 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    | 98.201     | 98.201     | 98.201     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074451   | 0.074451   | 0.074451   |   0.0 |  0.08
Output  | 0.00015617 | 0.00015617 | 0.00015617 |   0.0 |  0.00
Modify  | 0.36617    | 0.36617    | 0.36617    |   0.0 |  0.37
Other   |            | 0.05649    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116600.0 ave      116600 max      116600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116600
Ave neighs/atom = 58.300000
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.723560577127, Press = -1.58359877645801
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8435.6755   -8435.6755   -8506.6933   -8506.6933    274.84594    274.84594    23713.229    23713.229   -242.85043   -242.85043 
   23000   -8438.8842   -8438.8842    -8507.148    -8507.148    264.18798    264.18798    23698.251    23698.251    551.46703    551.46703 
Loop time of 98.6166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.393 hours/ns, 10.140 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    | 98.122     | 98.122     | 98.122     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074062   | 0.074062   | 0.074062   |   0.0 |  0.08
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.36418    | 0.36418    | 0.36418    |   0.0 |  0.37
Other   |            | 0.05632    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 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:      116676.0 ave      116676 max      116676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116676
Ave neighs/atom = 58.338000
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.585348857721, Press = -1.55859081210515
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8438.8842   -8438.8842    -8507.148    -8507.148    264.18798    264.18798    23698.251    23698.251    551.46703    551.46703 
   24000   -8437.1151   -8437.1151   -8507.0125   -8507.0125    270.51037    270.51037    23684.993    23684.993    1637.2421    1637.2421 
Loop time of 98.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.403 hours/ns, 10.137 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    | 98.154     | 98.154     | 98.154     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074896   | 0.074896   | 0.074896   |   0.0 |  0.08
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.36553    | 0.36553    | 0.36553    |   0.0 |  0.37
Other   |            | 0.05613    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 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:      116688.0 ave      116688 max      116688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116688
Ave neighs/atom = 58.344000
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.600844441869, Press = 1.23205218868873
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8437.1151   -8437.1151   -8507.0125   -8507.0125    270.51037    270.51037    23684.993    23684.993    1637.2421    1637.2421 
   25000   -8438.9702   -8438.9702    -8508.744    -8508.744    270.03189    270.03189    23746.969    23746.969   -3249.1608   -3249.1608 
Loop time of 98.0982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.250 hours/ns, 10.194 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    | 97.607     | 97.607     | 97.607     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073913   | 0.073913   | 0.073913   |   0.0 |  0.08
Output  | 0.00015622 | 0.00015622 | 0.00015622 |   0.0 |  0.00
Modify  | 0.36105    | 0.36105    | 0.36105    |   0.0 |  0.37
Other   |            | 0.05657    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116666.0 ave      116666 max      116666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116666
Ave neighs/atom = 58.333000
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.48501558281, Press = -0.283152823939808
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8438.9702   -8438.9702    -8508.744    -8508.744    270.03189    270.03189    23746.969    23746.969   -3249.1608   -3249.1608 
   26000   -8434.3417   -8434.3417    -8508.004    -8508.004    285.08089    285.08089    23711.204    23711.204   -229.74643   -229.74643 
Loop time of 100.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.778 hours/ns, 10.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    | 99.498     | 99.498     | 99.498     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075227   | 0.075227   | 0.075227   |   0.0 |  0.08
Output  | 0.00019547 | 0.00019547 | 0.00019547 |   0.0 |  0.00
Modify  | 0.37214    | 0.37214    | 0.37214    |   0.0 |  0.37
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 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:      116582.0 ave      116582 max      116582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116582
Ave neighs/atom = 58.291000
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.461883539474, Press = -4.31610485042512
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8434.3417   -8434.3417    -8508.004    -8508.004    285.08089    285.08089    23711.204    23711.204   -229.74643   -229.74643 
   27000   -8436.6134   -8436.6134   -8507.5688   -8507.5688    274.60492    274.60492    23690.484    23690.484     1132.688     1132.688 
Loop time of 100.744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.985 hours/ns, 9.926 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    | 100.23     | 100.23     | 100.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075555   | 0.075555   | 0.075555   |   0.0 |  0.07
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.37613    | 0.37613    | 0.37613    |   0.0 |  0.37
Other   |            | 0.05744    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 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:      116600.0 ave      116600 max      116600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116600
Ave neighs/atom = 58.300000
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.456070924172, Press = -0.231727612604693
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8436.6134   -8436.6134   -8507.5688   -8507.5688    274.60492    274.60492    23690.484    23690.484     1132.688     1132.688 
   28000   -8434.8559   -8434.8559   -8508.2732   -8508.2732    284.13265    284.13265    23715.707    23715.707   -693.88788   -693.88788 
Loop time of 99.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.530 hours/ns, 10.090 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    | 98.608     | 98.608     | 98.608     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074892   | 0.074892   | 0.074892   |   0.0 |  0.08
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.36761    | 0.36761    | 0.36761    |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116598.0 ave      116598 max      116598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116598
Ave neighs/atom = 58.299000
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.538158881656, Press = -0.529168171407699
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8434.8559   -8434.8559   -8508.2732   -8508.2732    284.13265    284.13265    23715.707    23715.707   -693.88788   -693.88788 
   29000   -8436.2815   -8436.2815   -8505.0087   -8505.0087    265.98128    265.98128    23705.016    23705.016    480.04628    480.04628 
Loop time of 97.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.085 hours/ns, 10.256 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    | 97.015     | 97.015     | 97.015     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07426    | 0.07426    | 0.07426    |   0.0 |  0.08
Output  | 0.00015527 | 0.00015527 | 0.00015527 |   0.0 |  0.00
Modify  | 0.36014    | 0.36014    | 0.36014    |   0.0 |  0.37
Other   |            | 0.05608    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 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:      116618.0 ave      116618 max      116618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116618
Ave neighs/atom = 58.309000
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.521853150239, Press = -1.7507439119854
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8436.2815   -8436.2815   -8505.0087   -8505.0087    265.98128    265.98128    23705.016    23705.016    480.04628    480.04628 
   30000   -8437.4676   -8437.4676   -8507.5539   -8507.5539    271.24119    271.24119    23697.082    23697.082    650.23854    650.23854 
Loop time of 99.0641 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.518 hours/ns, 10.094 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    | 98.569     | 98.569     | 98.569     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074746   | 0.074746   | 0.074746   |   0.0 |  0.08
Output  | 0.0001561  | 0.0001561  | 0.0001561  |   0.0 |  0.00
Modify  | 0.36386    | 0.36386    | 0.36386    |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 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:      116696.0 ave      116696 max      116696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116696
Ave neighs/atom = 58.348000
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.54778259868, Press = -0.815832820656344
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8437.4676   -8437.4676   -8507.5539   -8507.5539    271.24119    271.24119    23697.082    23697.082    650.23854    650.23854 
   31000   -8429.8647   -8429.8647   -8503.5183   -8503.5183    285.04693    285.04693    23720.254    23720.254   -162.48769   -162.48769 
Loop time of 99.9056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.752 hours/ns, 10.009 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.405     | 99.405     | 99.405     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074658   | 0.074658   | 0.074658   |   0.0 |  0.07
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.36964    | 0.36964    | 0.36964    |   0.0 |  0.37
Other   |            | 0.05648    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 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:      116642.0 ave      116642 max      116642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116642
Ave neighs/atom = 58.321000
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.63703758404, Press = -0.0631694301171569
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8429.8647   -8429.8647   -8503.5183   -8503.5183    285.04693    285.04693    23720.254    23720.254   -162.48769   -162.48769 
   32000   -8438.0198   -8438.0198   -8507.9035   -8507.9035    270.45709    270.45709    23715.693    23715.693   -804.68924   -804.68924 
Loop time of 98.4394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.344 hours/ns, 10.159 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    | 97.944     | 97.944     | 97.944     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073832   | 0.073832   | 0.073832   |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.3651     | 0.3651     | 0.3651     |   0.0 |  0.37
Other   |            | 0.05619    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116696.0 ave      116696 max      116696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116696
Ave neighs/atom = 58.348000
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.691090784212, Press = -1.72713763864925
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8438.0198   -8438.0198   -8507.9035   -8507.9035    270.45709    270.45709    23715.693    23715.693   -804.68924   -804.68924 
   33000   -8438.8713   -8438.8713   -8508.9176   -8508.9176    271.08627    271.08627    23691.007    23691.007      784.458      784.458 
Loop time of 99.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.760 hours/ns, 10.007 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.43      | 99.43      | 99.43      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074884   | 0.074884   | 0.074884   |   0.0 |  0.07
Output  | 0.00015537 | 0.00015537 | 0.00015537 |   0.0 |  0.00
Modify  | 0.3731     | 0.3731     | 0.3731     |   0.0 |  0.37
Other   |            | 0.05725    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116648.0 ave      116648 max      116648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116648
Ave neighs/atom = 58.324000
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.696614545563, Press = -1.49138202014318
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8438.8713   -8438.8713   -8508.9176   -8508.9176    271.08627    271.08627    23691.007    23691.007      784.458      784.458 
   34000   -8435.7879   -8435.7879   -8505.7771   -8505.7771    270.86507    270.86507    23704.595    23704.595    372.93655    372.93655 
Loop time of 100.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 27.989 hours/ns, 9.924 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    | 100.25     | 100.25     | 100.25     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075096   | 0.075096   | 0.075096   |   0.0 |  0.07
Output  | 0.00015217 | 0.00015217 | 0.00015217 |   0.0 |  0.00
Modify  | 0.37462    | 0.37462    | 0.37462    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 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:      116624.0 ave      116624 max      116624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116624
Ave neighs/atom = 58.312000
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.711312427819, Press = 0.937960895683406
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8435.7879   -8435.7879   -8505.7771   -8505.7771    270.86507    270.86507    23704.595    23704.595    372.93655    372.93655 
   35000   -8433.3963   -8433.3963   -8506.4367   -8506.4367    282.67403    282.67403    23751.344    23751.344   -2802.8665   -2802.8665 
Loop time of 99.0331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.509 hours/ns, 10.098 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    | 98.531     | 98.531     | 98.531     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075244   | 0.075244   | 0.075244   |   0.0 |  0.08
Output  | 0.00015475 | 0.00015475 | 0.00015475 |   0.0 |  0.00
Modify  | 0.37017    | 0.37017    | 0.37017    |   0.0 |  0.37
Other   |            | 0.05651    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 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:      116604.0 ave      116604 max      116604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116604
Ave neighs/atom = 58.302000
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.760799554314, Press = -2.16651823376417
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8433.3963   -8433.3963   -8506.4367   -8506.4367    282.67403    282.67403    23751.344    23751.344   -2802.8665   -2802.8665 
   36000   -8436.8238   -8436.8238   -8507.2306   -8507.2306     272.4817     272.4817    23679.072    23679.072    1956.3124    1956.3124 
Loop time of 99.3663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.602 hours/ns, 10.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    | 98.868     | 98.868     | 98.868     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07418    | 0.07418    | 0.07418    |   0.0 |  0.07
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.36746    | 0.36746    | 0.36746    |   0.0 |  0.37
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2952.00 ave        2952 max        2952 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:      116588.0 ave      116588 max      116588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116588
Ave neighs/atom = 58.294000
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.828181012291, Press = -2.07263921233381
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8436.8238   -8436.8238   -8507.2306   -8507.2306     272.4817     272.4817    23679.072    23679.072    1956.3124    1956.3124 
   37000   -8437.0943   -8437.0943   -8507.1197   -8507.1197    271.00547    271.00547     23700.87     23700.87    371.36145    371.36145 
Loop time of 100.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.988 hours/ns, 9.925 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    | 100.24     | 100.24     | 100.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075951   | 0.075951   | 0.075951   |   0.0 |  0.08
Output  | 0.00019557 | 0.00019557 | 0.00019557 |   0.0 |  0.00
Modify  | 0.37746    | 0.37746    | 0.37746    |   0.0 |  0.37
Other   |            | 0.05744    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 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:      116662.0 ave      116662 max      116662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116662
Ave neighs/atom = 58.331000
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.868931508053, Press = 0.820187454703778
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8437.0943   -8437.0943   -8507.1197   -8507.1197    271.00547    271.00547     23700.87     23700.87    371.36145    371.36145 
   38000   -8436.8031   -8436.8031   -8506.1265   -8506.1265    268.28862    268.28862    23732.274    23732.274   -1705.9123   -1705.9123 
Loop time of 98.6694 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.408 hours/ns, 10.135 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    | 98.173     | 98.173     | 98.173     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074692   | 0.074692   | 0.074692   |   0.0 |  0.08
Output  | 0.00015285 | 0.00015285 | 0.00015285 |   0.0 |  0.00
Modify  | 0.36491    | 0.36491    | 0.36491    |   0.0 |  0.37
Other   |            | 0.05673    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 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:      116644.0 ave      116644 max      116644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116644
Ave neighs/atom = 58.322000
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.935044262803, Press = -1.71669470158105
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8436.8031   -8436.8031   -8506.1265   -8506.1265    268.28862    268.28862    23732.274    23732.274   -1705.9123   -1705.9123 
   39000   -8435.3512   -8435.3512    -8506.317    -8506.317    274.64498    274.64498    23687.246    23687.246    1599.6992    1599.6992 
Loop time of 98.2218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.284 hours/ns, 10.181 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    | 97.729     | 97.729     | 97.729     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073773   | 0.073773   | 0.073773   |   0.0 |  0.08
Output  | 0.00019801 | 0.00019801 | 0.00019801 |   0.0 |  0.00
Modify  | 0.36218    | 0.36218    | 0.36218    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116646.0 ave      116646 max      116646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116646
Ave neighs/atom = 58.323000
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.916715696177, Press = -1.52831902868397
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8435.3512   -8435.3512    -8506.317    -8506.317    274.64498    274.64498    23687.246    23687.246    1599.6992    1599.6992 
   40000   -8432.8485   -8432.8485   -8504.5045   -8504.5045    277.31636    277.31636     23694.31     23694.31    1387.1772    1387.1772 
Loop time of 100.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 28.016 hours/ns, 9.915 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    | 100.35     | 100.35     | 100.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075523   | 0.075523   | 0.075523   |   0.0 |  0.07
Output  | 0.00018577 | 0.00018577 | 0.00018577 |   0.0 |  0.00
Modify  | 0.37631    | 0.37631    | 0.37631    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 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:      116686.0 ave      116686 max      116686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116686
Ave neighs/atom = 58.343000
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.977622602836, Press = 3.30341261156884
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8432.8485   -8432.8485   -8504.5045   -8504.5045    277.31636    277.31636     23694.31     23694.31    1387.1772    1387.1772 
   41000   -8436.4068   -8436.4068   -8505.7707   -8505.7707    268.44517    268.44517     23750.13     23750.13   -2832.9089   -2832.9089 
Loop time of 99.8579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.738 hours/ns, 10.014 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    | 99.353     | 99.353     | 99.353     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075229   | 0.075229   | 0.075229   |   0.0 |  0.08
Output  | 0.0004478  | 0.0004478  | 0.0004478  |   0.0 |  0.00
Modify  | 0.37206    | 0.37206    | 0.37206    |   0.0 |  0.37
Other   |            | 0.05668    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 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:      116684.0 ave      116684 max      116684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116684
Ave neighs/atom = 58.342000
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.00100633413, Press = -1.27608098653536
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8436.4068   -8436.4068   -8505.7707   -8505.7707    268.44517    268.44517     23750.13     23750.13   -2832.9089   -2832.9089 
   42000   -8433.8118   -8433.8118   -8505.6575   -8505.6575    278.05037    278.05037    23699.408    23699.408    860.25785    860.25785 
Loop time of 98.716 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.421 hours/ns, 10.130 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    | 98.218     | 98.218     | 98.218     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07416    | 0.07416    | 0.07416    |   0.0 |  0.08
Output  | 0.00015787 | 0.00015787 | 0.00015787 |   0.0 |  0.00
Modify  | 0.36702    | 0.36702    | 0.36702    |   0.0 |  0.37
Other   |            | 0.05618    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 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:      116584.0 ave      116584 max      116584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116584
Ave neighs/atom = 58.292000
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.084842236216, Press = -1.46174901063793
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8433.8118   -8433.8118   -8505.6575   -8505.6575    278.05037    278.05037    23699.408    23699.408    860.25785    860.25785 
   43000   -8434.7797   -8434.7797   -8504.5505   -8504.5505    270.02019    270.02019    23705.879    23705.879    702.09551    702.09551 
Loop time of 97.8381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.177 hours/ns, 10.221 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    | 97.347     | 97.347     | 97.347     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074042   | 0.074042   | 0.074042   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.36095    | 0.36095    | 0.36095    |   0.0 |  0.37
Other   |            | 0.05615    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 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:      116636.0 ave      116636 max      116636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116636
Ave neighs/atom = 58.318000
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.072843731782, Press = 0.42492705038143
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8434.7797   -8434.7797   -8504.5505   -8504.5505    270.02019    270.02019    23705.879    23705.879    702.09551    702.09551 
   44000   -8439.6084   -8439.6084   -8508.8642   -8508.8642    268.02714    268.02714    23723.061    23723.061    -1488.479    -1488.479 
Loop time of 99.1818 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.550 hours/ns, 10.082 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    | 98.678     | 98.678     | 98.678     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075849   | 0.075849   | 0.075849   |   0.0 |  0.08
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.37174    | 0.37174    | 0.37174    |   0.0 |  0.37
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 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:      116688.0 ave      116688 max      116688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116688
Ave neighs/atom = 58.344000
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.030660634573, Press = -0.877934288091088
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8439.6084   -8439.6084   -8508.8642   -8508.8642    268.02714    268.02714    23723.061    23723.061    -1488.479    -1488.479 
   45000   -8435.3375   -8435.3375   -8508.6249   -8508.6249    283.62973    283.62973    23694.904    23694.904    689.22121    689.22121 
Loop time of 99.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.572 hours/ns, 10.075 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    | 98.763     | 98.763     | 98.763     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075067   | 0.075067   | 0.075067   |   0.0 |  0.08
Output  | 0.00015287 | 0.00015287 | 0.00015287 |   0.0 |  0.00
Modify  | 0.36554    | 0.36554    | 0.36554    |   0.0 |  0.37
Other   |            | 0.05621    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 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:      116556.0 ave      116556 max      116556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116556
Ave neighs/atom = 58.278000
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.988282859684, Press = -1.55263758771999
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8435.3375   -8435.3375   -8508.6249   -8508.6249    283.62973    283.62973    23694.904    23694.904    689.22121    689.22121 
   46000   -8435.1367   -8435.1367   -8506.4609   -8506.4609    276.03193    276.03193    23678.049    23678.049    2224.8215    2224.8215 
Loop time of 99.4375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.622 hours/ns, 10.057 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    | 98.936     | 98.936     | 98.936     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0748     | 0.0748     | 0.0748     |   0.0 |  0.08
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.36982    | 0.36982    | 0.36982    |   0.0 |  0.37
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 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:      116604.0 ave      116604 max      116604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116604
Ave neighs/atom = 58.302000
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.958993703157, Press = 1.78501343471826
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8435.1367   -8435.1367   -8506.4609   -8506.4609    276.03193    276.03193    23678.049    23678.049    2224.8215    2224.8215 
   47000   -8437.0615   -8437.0615   -8506.5766   -8506.5766    269.03068    269.03068    23748.587    23748.587   -2878.5051   -2878.5051 
Loop time of 100.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.842 hours/ns, 9.977 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    | 99.727     | 99.727     | 99.727     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07635    | 0.07635    | 0.07635    |   0.0 |  0.08
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.37178    | 0.37178    | 0.37178    |   0.0 |  0.37
Other   |            | 0.05726    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 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:      116708.0 ave      116708 max      116708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116708
Ave neighs/atom = 58.354000
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.017853843853, Press = -0.564035265059979
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8437.0615   -8437.0615   -8506.5766   -8506.5766    269.03068    269.03068    23748.587    23748.587   -2878.5051   -2878.5051 
   48000   -8433.6454   -8433.6454   -8505.2291   -8505.2291    277.03638    277.03638    23706.848    23706.848    475.21762    475.21762 
Loop time of 99.3416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.595 hours/ns, 10.066 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    | 98.843     | 98.843     | 98.843     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074569   | 0.074569   | 0.074569   |   0.0 |  0.08
Output  | 0.00015486 | 0.00015486 | 0.00015486 |   0.0 |  0.00
Modify  | 0.36779    | 0.36779    | 0.36779    |   0.0 |  0.37
Other   |            | 0.05654    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 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:      116584.0 ave      116584 max      116584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116584
Ave neighs/atom = 58.292000
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.052768624272, Press = -1.15846505724166
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8433.6454   -8433.6454   -8505.2291   -8505.2291    277.03638    277.03638    23706.848    23706.848    475.21762    475.21762 
   49000   -8437.7708   -8437.7708   -8506.9129   -8506.9129     267.5874     267.5874     23692.34     23692.34    1079.7575    1079.7575 
Loop time of 98.8143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.448 hours/ns, 10.120 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    | 98.317     | 98.317     | 98.317     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074248   | 0.074248   | 0.074248   |   0.0 |  0.08
Output  | 0.00015376 | 0.00015376 | 0.00015376 |   0.0 |  0.00
Modify  | 0.36632    | 0.36632    | 0.36632    |   0.0 |  0.37
Other   |            | 0.05694    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 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:      116650.0 ave      116650 max      116650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116650
Ave neighs/atom = 58.325000
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
23708.0771205042

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0