# 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.002 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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   -8493.9171   -8493.9171        -8580        -8580       333.15       333.15    23483.518    23483.518    3915.3602    3915.3602 
    1000   -8403.2191   -8403.2191   -8485.7345   -8485.7345    319.34322    319.34322    23777.874    23777.874   -774.30946   -774.30946 
Loop time of 97.5132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.087 hours/ns, 10.255 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.027     | 97.027     | 97.027     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076547   | 0.076547   | 0.076547   |   0.0 |  0.08
Output  | 0.00020191 | 0.00020191 | 0.00020191 |   0.0 |  0.00
Modify  | 0.35187    | 0.35187    | 0.35187    |   0.0 |  0.36
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:        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   -8403.2191   -8403.2191   -8485.7345   -8485.7345    319.34322    319.34322    23777.874    23777.874   -774.30946   -774.30946 
    2000   -8404.1366   -8404.1366   -8488.8528   -8488.8528    327.86032    327.86032    23787.917    23787.917   -1855.3108   -1855.3108 
Loop time of 99.0842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.523 hours/ns, 10.092 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.609     | 98.609     | 98.609     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07452    | 0.07452    | 0.07452    |   0.0 |  0.08
Output  | 0.00019328 | 0.00019328 | 0.00019328 |   0.0 |  0.00
Modify  | 0.34355    | 0.34355    | 0.34355    |   0.0 |  0.35
Other   |            | 0.05719    |            |       |  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:      116986.0 ave      116986 max      116986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116986
Ave neighs/atom = 58.493000
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   -8404.1366   -8404.1366   -8488.8528   -8488.8528    327.86032    327.86032    23787.917    23787.917   -1855.3108   -1855.3108 
    3000   -8405.2295   -8405.2295   -8486.2363   -8486.2363    313.50468    313.50468    23742.799    23742.799    1602.1027    1602.1027 
Loop time of 99.8228 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.34      | 99.34      | 99.34      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076019   | 0.076019   | 0.076019   |   0.0 |  0.08
Output  | 0.00018515 | 0.00018515 | 0.00018515 |   0.0 |  0.00
Modify  | 0.34911    | 0.34911    | 0.34911    |   0.0 |  0.35
Other   |            | 0.05754    |            |       |  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:      116824.0 ave      116824 max      116824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116824
Ave neighs/atom = 58.412000
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   -8405.2295   -8405.2295   -8486.2363   -8486.2363    313.50468    313.50468    23742.799    23742.799    1602.1027    1602.1027 
    4000   -8402.7949   -8402.7949   -8491.5321   -8491.5321    343.42246    343.42246    23735.915    23735.915    1545.7965    1545.7965 
Loop time of 100.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.833 hours/ns, 9.980 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.716     | 99.716     | 99.716     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076131   | 0.076131   | 0.076131   |   0.0 |  0.08
Output  | 0.0002267  | 0.0002267  | 0.0002267  |   0.0 |  0.00
Modify  | 0.34836    | 0.34836    | 0.34836    |   0.0 |  0.35
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 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:      116906.0 ave      116906 max      116906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116906
Ave neighs/atom = 58.453000
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   -8402.7949   -8402.7949   -8491.5321   -8491.5321    343.42246    343.42246    23735.915    23735.915    1545.7965    1545.7965 
    5000   -8405.4713   -8405.4713    -8492.918    -8492.918    338.42746    338.42746     23775.81     23775.81   -1484.0279   -1484.0279 
Loop time of 99.4632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.629 hours/ns, 10.054 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.981     | 98.981     | 98.981     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075025   | 0.075025   | 0.075025   |   0.0 |  0.08
Output  | 0.00015616 | 0.00015616 | 0.00015616 |   0.0 |  0.00
Modify  | 0.34977    | 0.34977    | 0.34977    |   0.0 |  0.35
Other   |            | 0.05769    |            |       |  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:      116884.0 ave      116884 max      116884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116884
Ave neighs/atom = 58.442000
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 = 332.271763731045, Press = -406.186639383158
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   -8405.4713   -8405.4713    -8492.918    -8492.918    338.42746    338.42746     23775.81     23775.81   -1484.0279   -1484.0279 
    6000   -8403.0184   -8403.0184   -8490.2576   -8490.2576    337.62463    337.62463    23760.648    23760.648   -3.7148173   -3.7148173 
Loop time of 100.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.032 hours/ns, 9.909 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.41     | 100.41     | 100.41     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076675   | 0.076675   | 0.076675   |   0.0 |  0.08
Output  | 0.00015368 | 0.00015368 | 0.00015368 |   0.0 |  0.00
Modify  | 0.37171    | 0.37171    | 0.37171    |   0.0 |  0.37
Other   |            | 0.05791    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 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:      116752.0 ave      116752 max      116752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116752
Ave neighs/atom = 58.376000
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 = 331.794216061294, Press = 13.0057102591213
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   -8403.0184   -8403.0184   -8490.2576   -8490.2576    337.62463    337.62463    23760.648    23760.648   -3.7148173   -3.7148173 
    7000   -8404.0415   -8404.0415   -8490.7759   -8490.7759    335.67114    335.67114    23763.668    23763.668   -354.90252   -354.90252 
Loop time of 100.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.929 hours/ns, 9.946 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.04     | 100.04     | 100.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077109   | 0.077109   | 0.077109   |   0.0 |  0.08
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.37348    | 0.37348    | 0.37348    |   0.0 |  0.37
Other   |            | 0.05806    |            |       |  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:      116794.0 ave      116794 max      116794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116794
Ave neighs/atom = 58.397000
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 = 332.874100227258, Press = -16.3591272315833
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   -8404.0415   -8404.0415   -8490.7759   -8490.7759    335.67114    335.67114    23763.668    23763.668   -354.90252   -354.90252 
    8000   -8401.1428   -8401.1428   -8488.6013   -8488.6013    338.47347    338.47347    23787.589    23787.589   -1671.7471   -1671.7471 
Loop time of 100.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.933 hours/ns, 9.944 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    | 100.05     | 100.05     | 100.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076463   | 0.076463   | 0.076463   |   0.0 |  0.08
Output  | 0.00019499 | 0.00019499 | 0.00019499 |   0.0 |  0.00
Modify  | 0.37357    | 0.37357    | 0.37357    |   0.0 |  0.37
Other   |            | 0.05788    |            |       |  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:      116828.0 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414000
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 = 332.883625912602, Press = 7.3998166570474
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   -8401.1428   -8401.1428   -8488.6013   -8488.6013    338.47347    338.47347    23787.589    23787.589   -1671.7471   -1671.7471 
    9000   -8405.1185   -8405.1185   -8487.9676   -8487.9676    320.63474    320.63474    23733.829    23733.829    2104.7604    2104.7604 
Loop time of 99.6354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.677 hours/ns, 10.037 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.132     | 99.132     | 99.132     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075659   | 0.075659   | 0.075659   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.37065    | 0.37065    | 0.37065    |   0.0 |  0.37
Other   |            | 0.05735    |            |       |  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:      116888.0 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444000
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 = 332.864809708596, Press = 15.6011555279443
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   -8405.1185   -8405.1185   -8487.9676   -8487.9676    320.63474    320.63474    23733.829    23733.829    2104.7604    2104.7604 
   10000   -8402.8072   -8402.8072    -8488.778    -8488.778    332.71606    332.71606    23733.922    23733.922    2009.2303    2009.2303 
Loop time of 99.9322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.759 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.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075938   | 0.075938   | 0.075938   |   0.0 |  0.08
Output  | 0.00015751 | 0.00015751 | 0.00015751 |   0.0 |  0.00
Modify  | 0.36757    | 0.36757    | 0.36757    |   0.0 |  0.37
Other   |            | 0.05806    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2974.00 ave        2974 max        2974 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:      116946.0 ave      116946 max      116946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116946
Ave neighs/atom = 58.473000
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 = 333.020731828832, Press = -14.2592635124779
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   -8402.8072   -8402.8072    -8488.778    -8488.778    332.71606    332.71606    23733.922    23733.922    2009.2303    2009.2303 
   11000   -8404.0108   -8404.0108   -8490.2925   -8490.2925    333.91908    333.91908    23802.371    23802.371   -3030.3272   -3030.3272 
Loop time of 100.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.910 hours/ns, 9.953 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.972     | 99.972     | 99.972     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076559   | 0.076559   | 0.076559   |   0.0 |  0.08
Output  | 0.00014583 | 0.00014583 | 0.00014583 |   0.0 |  0.00
Modify  | 0.37068    | 0.37068    | 0.37068    |   0.0 |  0.37
Other   |            | 0.05751    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2975.00 ave        2975 max        2975 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:      116910.0 ave      116910 max      116910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116910
Ave neighs/atom = 58.455000
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 = 333.110812094375, Press = -8.42949402791573
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   -8404.0108   -8404.0108   -8490.2925   -8490.2925    333.91908    333.91908    23802.371    23802.371   -3030.3272   -3030.3272 
   12000   -8408.5074   -8408.5074   -8492.4204   -8492.4204    324.75224    324.75224    23755.357    23755.357   -161.20346   -161.20346 
Loop time of 98.8733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.465 hours/ns, 10.114 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.378     | 98.378     | 98.378     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075653   | 0.075653   | 0.075653   |   0.0 |  0.08
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.3628     | 0.3628     | 0.3628     |   0.0 |  0.37
Other   |            | 0.05707    |            |       |  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:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
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 = 332.803423165105, Press = 8.97283725078752
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   -8408.5074   -8408.5074   -8492.4204   -8492.4204    324.75224    324.75224    23755.357    23755.357   -161.20346   -161.20346 
   13000     -8404.12     -8404.12   -8488.5906   -8488.5906    326.90978    326.90978    23742.675    23742.675    1447.3373    1447.3373 
Loop time of 98.8771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.466 hours/ns, 10.114 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.385     | 98.385     | 98.385     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075047   | 0.075047   | 0.075047   |   0.0 |  0.08
Output  | 0.00015695 | 0.00015695 | 0.00015695 |   0.0 |  0.00
Modify  | 0.35973    | 0.35973    | 0.35973    |   0.0 |  0.36
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2975.00 ave        2975 max        2975 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:      116842.0 ave      116842 max      116842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116842
Ave neighs/atom = 58.421000
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 = 332.653344367097, Press = -1.73179694413804
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     -8404.12     -8404.12   -8488.5906   -8488.5906    326.90978    326.90978    23742.675    23742.675    1447.3373    1447.3373 
   14000   -8401.9263   -8401.9263    -8490.711    -8490.711    343.60609    343.60609    23776.697    23776.697   -1201.1108   -1201.1108 
Loop time of 100.344 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.841     | 99.841     | 99.841     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075894   | 0.075894   | 0.075894   |   0.0 |  0.08
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.36959    | 0.36959    | 0.36959    |   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:        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:      116930.0 ave      116930 max      116930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116930
Ave neighs/atom = 58.465000
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 = 332.715115377332, Press = -3.97503028772999
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   -8401.9263   -8401.9263    -8490.711    -8490.711    343.60609    343.60609    23776.697    23776.697   -1201.1108   -1201.1108 
   15000   -8406.4963   -8406.4963   -8493.2863   -8493.2863    335.88655    335.88655    23770.821    23770.821   -1139.3751   -1139.3751 
Loop time of 99.7689 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.268     | 99.268     | 99.268     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074905   | 0.074905   | 0.074905   |   0.0 |  0.08
Output  | 0.00046729 | 0.00046729 | 0.00046729 |   0.0 |  0.00
Modify  | 0.36752    | 0.36752    | 0.36752    |   0.0 |  0.37
Other   |            | 0.05765    |            |       |  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:      116808.0 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404000
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 = 332.566730511629, Press = 1.05202687591336
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   -8406.4963   -8406.4963   -8493.2863   -8493.2863    335.88655    335.88655    23770.821    23770.821   -1139.3751   -1139.3751 
   16000   -8400.6861   -8400.6861   -8488.9115   -8488.9115    341.44114    341.44114    23722.388    23722.388    3080.8314    3080.8314 
Loop time of 99.3443 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.596 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.844     | 98.844     | 98.844     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075805   | 0.075805   | 0.075805   |   0.0 |  0.08
Output  | 0.00015662 | 0.00015662 | 0.00015662 |   0.0 |  0.00
Modify  | 0.36726    | 0.36726    | 0.36726    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 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:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
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 = 332.597738072717, Press = 5.07710526284324
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   -8400.6861   -8400.6861   -8488.9115   -8488.9115    341.44114    341.44114    23722.388    23722.388    3080.8314    3080.8314 
   17000    -8402.071    -8402.071   -8488.2935   -8488.2935    333.69004    333.69004    23737.834    23737.834    1896.2221    1896.2221 
Loop time of 99.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.612 hours/ns, 10.060 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.907     | 98.907     | 98.907     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075384   | 0.075384   | 0.075384   |   0.0 |  0.08
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.36401    | 0.36401    | 0.36401    |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 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:      116998.0 ave      116998 max      116998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116998
Ave neighs/atom = 58.499000
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 = 332.6840974641, Press = -8.65715974662355
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    -8402.071    -8402.071   -8488.2935   -8488.2935    333.69004    333.69004    23737.834    23737.834    1896.2221    1896.2221 
   18000   -8404.6874   -8404.6874   -8491.4062   -8491.4062    335.61084    335.61084    23793.627    23793.627   -2640.8894   -2640.8894 
Loop time of 99.5706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.658 hours/ns, 10.043 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.073     | 99.073     | 99.073     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075723   | 0.075723   | 0.075723   |   0.0 |  0.08
Output  | 0.00015422 | 0.00015422 | 0.00015422 |   0.0 |  0.00
Modify  | 0.36463    | 0.36463    | 0.36463    |   0.0 |  0.37
Other   |            | 0.05751    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 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:      116914.0 ave      116914 max      116914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116914
Ave neighs/atom = 58.457000
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 = 332.903053916427, Press = -2.31194996198508
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   -8404.6874   -8404.6874   -8491.4062   -8491.4062    335.61084    335.61084    23793.627    23793.627   -2640.8894   -2640.8894 
   19000    -8399.128    -8399.128   -8486.7688   -8486.7688    339.17886    339.17886    23765.072    23765.072    244.79284    244.79284 
Loop time of 99.3602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.600 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.863     | 98.863     | 98.863     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075644   | 0.075644   | 0.075644   |   0.0 |  0.08
Output  | 0.00015638 | 0.00015638 | 0.00015638 |   0.0 |  0.00
Modify  | 0.36464    | 0.36464    | 0.36464    |   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:        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:      116802.0 ave      116802 max      116802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116802
Ave neighs/atom = 58.401000
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 = 333.064135271085, Press = 4.01980669234838
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    -8399.128    -8399.128   -8486.7688   -8486.7688    339.17886    339.17886    23765.072    23765.072    244.79284    244.79284 
   20000   -8403.7106   -8403.7106   -8491.3093   -8491.3093     339.0159     339.0159    23734.223    23734.223    1557.3505    1557.3505 
Loop time of 98.5936 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.387 hours/ns, 10.143 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.097     | 98.097     | 98.097     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075135   | 0.075135   | 0.075135   |   0.0 |  0.08
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.3635     | 0.3635     | 0.3635     |   0.0 |  0.37
Other   |            | 0.05782    |            |       |  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:      116876.0 ave      116876 max      116876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116876
Ave neighs/atom = 58.438000
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 = 333.197412903871, Press = -1.10543234203039
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   -8403.7106   -8403.7106   -8491.3093   -8491.3093     339.0159     339.0159    23734.223    23734.223    1557.3505    1557.3505 
   21000   -8404.8239   -8404.8239   -8489.5787   -8489.5787    328.00977    328.00977    23772.575    23772.575   -758.15077   -758.15077 
Loop time of 98.7624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.434 hours/ns, 10.125 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.267     | 98.267     | 98.267     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075282   | 0.075282   | 0.075282   |   0.0 |  0.08
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.36248    | 0.36248    | 0.36248    |   0.0 |  0.37
Other   |            | 0.05702    |            |       |  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:      116956.0 ave      116956 max      116956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116956
Ave neighs/atom = 58.478000
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 = 333.152347724162, Press = -2.54779663529977
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   -8404.8239   -8404.8239   -8489.5787   -8489.5787    328.00977    328.00977    23772.575    23772.575   -758.15077   -758.15077 
   22000   -8402.5985   -8402.5985    -8490.365    -8490.365     339.6655     339.6655    23778.576    23778.576   -1174.0083   -1174.0083 
Loop time of 98.2213 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.728     | 97.728     | 97.728     |   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.00025304 | 0.00025304 | 0.00025304 |   0.0 |  0.00
Modify  | 0.36073    | 0.36073    | 0.36073    |   0.0 |  0.37
Other   |            | 0.05689    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 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:      116888.0 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444000
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 = 333.077101526651, Press = 2.12136783213957
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   -8402.5985   -8402.5985    -8490.365    -8490.365     339.6655     339.6655    23778.576    23778.576   -1174.0083   -1174.0083 
   23000   -8407.1233   -8407.1233   -8492.7553   -8492.7553    331.40451    331.40451    23720.392    23720.392    2353.9575    2353.9575 
Loop time of 99.2844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.579 hours/ns, 10.072 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.788     | 98.788     | 98.788     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075325   | 0.075325   | 0.075325   |   0.0 |  0.08
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.36378    | 0.36378    | 0.36378    |   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:        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:      116784.0 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392000
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 = 332.957831789569, Press = 0.662581676571458
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   -8407.1233   -8407.1233   -8492.7553   -8492.7553    331.40451    331.40451    23720.392    23720.392    2353.9575    2353.9575 
   24000   -8402.8037   -8402.8037   -8488.2051   -8488.2051    330.51247    330.51247    23769.997    23769.997   -384.98693   -384.98693 
Loop time of 100.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.877 hours/ns, 9.965 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.851     | 99.851     | 99.851     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076678   | 0.076678   | 0.076678   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.36947    | 0.36947    | 0.36947    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 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:      116848.0 ave      116848 max      116848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116848
Ave neighs/atom = 58.424000
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 = 332.920570183962, Press = -5.01284837751977
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   -8402.8037   -8402.8037   -8488.2051   -8488.2051    330.51247    330.51247    23769.997    23769.997   -384.98693   -384.98693 
   25000   -8402.9566   -8402.9566   -8488.4693   -8488.4693     330.9427     330.9427    23798.359    23798.359   -2320.2681   -2320.2681 
Loop time of 99.283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.579 hours/ns, 10.072 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.783     | 98.783     | 98.783     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075352   | 0.075352   | 0.075352   |   0.0 |  0.08
Output  | 0.00014946 | 0.00014946 | 0.00014946 |   0.0 |  0.00
Modify  | 0.36713    | 0.36713    | 0.36713    |   0.0 |  0.37
Other   |            | 0.05782    |            |       |  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:      116810.0 ave      116810 max      116810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116810
Ave neighs/atom = 58.405000
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 = 332.928277692681, Press = 1.36085847920058
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   -8402.9566   -8402.9566   -8488.4693   -8488.4693     330.9427     330.9427    23798.359    23798.359   -2320.2681   -2320.2681 
   26000   -8405.5239   -8405.5239   -8492.0391   -8492.0391    334.82269    334.82269     23736.42     23736.42    1359.9136    1359.9136 
Loop time of 99.1463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.541 hours/ns, 10.086 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.646     | 98.646     | 98.646     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075716   | 0.075716   | 0.075716   |   0.0 |  0.08
Output  | 0.00015436 | 0.00015436 | 0.00015436 |   0.0 |  0.00
Modify  | 0.367      | 0.367      | 0.367      |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  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:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
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 = 333.090651253327, Press = 1.77496255763714
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   -8405.5239   -8405.5239   -8492.0391   -8492.0391    334.82269    334.82269     23736.42     23736.42    1359.9136    1359.9136 
   27000    -8403.581    -8403.581   -8489.3666   -8489.3666    331.99922    331.99922    23745.134    23745.134    1165.8092    1165.8092 
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.499     | 99.499     | 99.499     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075562   | 0.075562   | 0.075562   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.36896    | 0.36896    | 0.36896    |   0.0 |  0.37
Other   |            | 0.05872    |            |       |  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:      116856.0 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428000
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 = 333.152259304331, Press = -1.64651104320825
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    -8403.581    -8403.581   -8489.3666   -8489.3666    331.99922    331.99922    23745.134    23745.134    1165.8092    1165.8092 
   28000   -8406.1283   -8406.1283   -8489.6756   -8489.6756    323.33665    323.33665    23758.977    23758.977   -2.8318935   -2.8318935 
Loop time of 98.2979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.305 hours/ns, 10.173 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.805     | 97.805     | 97.805     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075264   | 0.075264   | 0.075264   |   0.0 |  0.08
Output  | 0.0001487  | 0.0001487  | 0.0001487  |   0.0 |  0.00
Modify  | 0.36072    | 0.36072    | 0.36072    |   0.0 |  0.37
Other   |            | 0.05688    |            |       |  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:      116950.0 ave      116950 max      116950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116950
Ave neighs/atom = 58.475000
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 = 333.20671501114, Press = -0.693019874578679
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   -8406.1283   -8406.1283   -8489.6756   -8489.6756    323.33665    323.33665    23758.977    23758.977   -2.8318935   -2.8318935 
   29000   -8400.4649   -8400.4649   -8487.1265   -8487.1265    335.38928    335.38928    23761.555    23761.555    541.60623    541.60623 
Loop time of 97.4725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.076 hours/ns, 10.259 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    | 96.983     | 96.983     | 96.983     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074637   | 0.074637   | 0.074637   |   0.0 |  0.08
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.35802    | 0.35802    | 0.35802    |   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:        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:      116916.0 ave      116916 max      116916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116916
Ave neighs/atom = 58.458000
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 = 333.218002480355, Press = -0.621055059093185
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   -8400.4649   -8400.4649   -8487.1265   -8487.1265    335.38928    335.38928    23761.555    23761.555    541.60623    541.60623 
   30000   -8404.5072   -8404.5072   -8491.5316   -8491.5316    336.79348    336.79348    23769.412    23769.412   -903.95419   -903.95419 
Loop time of 98.7745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.437 hours/ns, 10.124 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.277     | 98.277     | 98.277     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075395   | 0.075395   | 0.075395   |   0.0 |  0.08
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.36417    | 0.36417    | 0.36417    |   0.0 |  0.37
Other   |            | 0.05756    |            |       |  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:      116808.0 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404000
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 = 333.323170942594, Press = -1.02656581401725
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   -8404.5072   -8404.5072   -8491.5316   -8491.5316    336.79348    336.79348    23769.412    23769.412   -903.95419   -903.95419 
   31000   -8399.8158   -8399.8158   -8485.7363   -8485.7363    332.52136    332.52136        23794        23794     -1556.36     -1556.36 
Loop time of 99.0674 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.519 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.571     | 98.571     | 98.571     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075096   | 0.075096   | 0.075096   |   0.0 |  0.08
Output  | 0.00019622 | 0.00019622 | 0.00019622 |   0.0 |  0.00
Modify  | 0.36321    | 0.36321    | 0.36321    |   0.0 |  0.37
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 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:      116852.0 ave      116852 max      116852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116852
Ave neighs/atom = 58.426000
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 = 333.368114850843, Press = 1.06973527630848
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   -8399.8158   -8399.8158   -8485.7363   -8485.7363    332.52136    332.52136        23794        23794     -1556.36     -1556.36 
   32000   -8404.0534   -8404.0534   -8491.8045   -8491.8045    339.60586    339.60586    23725.948    23725.948     2194.043     2194.043 
Loop time of 98.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.397 hours/ns, 10.139 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.134     | 98.134     | 98.134     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075009   | 0.075009   | 0.075009   |   0.0 |  0.08
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.3623     | 0.3623     | 0.3623     |   0.0 |  0.37
Other   |            | 0.0575     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2970.00 ave        2970 max        2970 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:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
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 = 333.312819128286, Press = 1.76566807829897
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   -8404.0534   -8404.0534   -8491.8045   -8491.8045    339.60586    339.60586    23725.948    23725.948     2194.043     2194.043 
   33000   -8402.8575   -8402.8575   -8488.7948   -8488.7948    332.58627    332.58627      23738.7      23738.7    1757.0391    1757.0391 
Loop time of 99.828 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.325     | 99.325     | 99.325     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076756   | 0.076756   | 0.076756   |   0.0 |  0.08
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.3686     | 0.3686     | 0.3686     |   0.0 |  0.37
Other   |            | 0.05782    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2977.00 ave        2977 max        2977 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:      116892.0 ave      116892 max      116892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116892
Ave neighs/atom = 58.446000
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 = 333.247961610695, Press = -2.43222421705099
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   -8402.8575   -8402.8575   -8488.7948   -8488.7948    332.58627    332.58627      23738.7      23738.7    1757.0391    1757.0391 
   34000   -8404.1981   -8404.1981   -8489.7843   -8489.7843    331.22743    331.22743    23781.148    23781.148   -1414.1586   -1414.1586 
Loop time of 102.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.507 hours/ns, 9.744 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    | 102.1      | 102.1      | 102.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077675   | 0.077675   | 0.077675   |   0.0 |  0.08
Output  | 0.00021596 | 0.00021596 | 0.00021596 |   0.0 |  0.00
Modify  | 0.38594    | 0.38594    | 0.38594    |   0.0 |  0.38
Other   |            | 0.0591     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2973.00 ave        2973 max        2973 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:      116952.0 ave      116952 max      116952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116952
Ave neighs/atom = 58.476000
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 = 333.145939025914, Press = -1.74103572622085
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   -8404.1981   -8404.1981   -8489.7843   -8489.7843    331.22743    331.22743    23781.148    23781.148   -1414.1586   -1414.1586 
   35000   -8406.1654   -8406.1654   -8491.4541   -8491.4541    330.07603    330.07603    23769.715    23769.715   -967.72694   -967.72694 
Loop time of 98.0453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.235 hours/ns, 10.199 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.554     | 97.554     | 97.554     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075334   | 0.075334   | 0.075334   |   0.0 |  0.08
Output  | 0.00020429 | 0.00020429 | 0.00020429 |   0.0 |  0.00
Modify  | 0.35926    | 0.35926    | 0.35926    |   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:        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:      116800.0 ave      116800 max      116800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116800
Ave neighs/atom = 58.400000
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 = 333.107364259283, Press = 0.72779226937211
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   -8406.1654   -8406.1654   -8491.4541   -8491.4541    330.07603    330.07603    23769.715    23769.715   -967.72694   -967.72694 
   36000   -8401.3413   -8401.3413   -8488.8992   -8488.8992     338.8579     338.8579    23736.285    23736.285    2036.1749    2036.1749 
Loop time of 99.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.598 hours/ns, 10.065 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.853     | 98.853     | 98.853     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075553   | 0.075553   | 0.075553   |   0.0 |  0.08
Output  | 0.00021669 | 0.00021669 | 0.00021669 |   0.0 |  0.00
Modify  | 0.36711    | 0.36711    | 0.36711    |   0.0 |  0.37
Other   |            | 0.05781    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 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:      116860.0 ave      116860 max      116860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116860
Ave neighs/atom = 58.430000
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 = 333.173368109058, Press = -0.445104975263616
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   -8401.3413   -8401.3413   -8488.8992   -8488.8992     338.8579     338.8579    23736.285    23736.285    2036.1749    2036.1749 
   37000   -8405.0409   -8405.0409     -8488.36     -8488.36    322.45359    322.45359    23771.219    23771.219   -604.60701   -604.60701 
Loop time of 100.793 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 27.998 hours/ns, 9.921 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.28     | 100.28     | 100.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076558   | 0.076558   | 0.076558   |   0.0 |  0.08
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.37625    | 0.37625    | 0.37625    |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  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:      116898.0 ave      116898 max      116898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116898
Ave neighs/atom = 58.449000
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 = 333.233348561595, Press = -2.72012012682172
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   -8405.0409   -8405.0409     -8488.36     -8488.36    322.45359    322.45359    23771.219    23771.219   -604.60701   -604.60701 
   38000    -8399.951    -8399.951   -8485.9897   -8485.9897    332.97846    332.97846    23818.753    23818.753   -3484.1477   -3484.1477 
Loop time of 98.8626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.462 hours/ns, 10.115 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.362     | 98.362     | 98.362     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075584   | 0.075584   | 0.075584   |   0.0 |  0.08
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.36717    | 0.36717    | 0.36717    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  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:      116944.0 ave      116944 max      116944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116944
Ave neighs/atom = 58.472000
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 = 333.323808539669, Press = 1.72499954803179
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    -8399.951    -8399.951   -8485.9897   -8485.9897    332.97846    332.97846    23818.753    23818.753   -3484.1477   -3484.1477 
   39000   -8402.4727   -8402.4727   -8488.7587   -8488.7587    333.93563    333.93563    23733.753    23733.753    2098.5687    2098.5687 
Loop time of 99.4549 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.075509   | 0.075509   | 0.075509   |   0.0 |  0.08
Output  | 0.00020169 | 0.00020169 | 0.00020169 |   0.0 |  0.00
Modify  | 0.36811    | 0.36811    | 0.36811    |   0.0 |  0.37
Other   |            | 0.0575     |            |       |  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:      116846.0 ave      116846 max      116846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116846
Ave neighs/atom = 58.423000
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 = 333.340256655704, Press = 1.2131046548307
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   -8402.4727   -8402.4727   -8488.7587   -8488.7587    333.93563    333.93563    23733.753    23733.753    2098.5687    2098.5687 
   40000   -8409.2227   -8409.2227   -8492.9581   -8492.9581    324.06458    324.06458    23736.009    23736.009    1290.8991    1290.8991 
Loop time of 100.314 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.809     | 99.809     | 99.809     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076137   | 0.076137   | 0.076137   |   0.0 |  0.08
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.37046    | 0.37046    | 0.37046    |   0.0 |  0.37
Other   |            | 0.05804    |            |       |  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:      116942.0 ave      116942 max      116942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116942
Ave neighs/atom = 58.471000
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 = 333.295569448958, Press = -1.88628752984218
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   -8409.2227   -8409.2227   -8492.9581   -8492.9581    324.06458    324.06458    23736.009    23736.009    1290.8991    1290.8991 
   41000   -8402.7755   -8402.7755   -8489.9816   -8489.9816    337.49642    337.49642    23793.895    23793.895   -2300.5151   -2300.5151 
Loop time of 98.9409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.484 hours/ns, 10.107 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.442     | 98.442     | 98.442     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075363   | 0.075363   | 0.075363   |   0.0 |  0.08
Output  | 0.00038316 | 0.00038316 | 0.00038316 |   0.0 |  0.00
Modify  | 0.36622    | 0.36622    | 0.36622    |   0.0 |  0.37
Other   |            | 0.05703    |            |       |  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:      116838.0 ave      116838 max      116838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116838
Ave neighs/atom = 58.419000
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 = 333.236011755524, Press = -0.526641261879355
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   -8402.7755   -8402.7755   -8489.9816   -8489.9816    337.49642    337.49642    23793.895    23793.895   -2300.5151   -2300.5151 
   42000   -8404.3402   -8404.3402   -8490.4421   -8490.4421    333.22356    333.22356    23759.027    23759.027   -31.951628   -31.951628 
Loop time of 98.8113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.448 hours/ns, 10.120 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.317     | 98.317     | 98.317     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075264   | 0.075264   | 0.075264   |   0.0 |  0.08
Output  | 0.00015037 | 0.00015037 | 0.00015037 |   0.0 |  0.00
Modify  | 0.36126    | 0.36126    | 0.36126    |   0.0 |  0.37
Other   |            | 0.05741    |            |       |  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:      116856.0 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428000
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 = 333.238962722794, Press = 1.07531666059152
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   -8404.3402   -8404.3402   -8490.4421   -8490.4421    333.22356    333.22356    23759.027    23759.027   -31.951628   -31.951628 
   43000   -8404.4806   -8404.4806   -8490.2216   -8490.2216    331.82656    331.82656    23707.816    23707.816    3759.2389    3759.2389 
Loop time of 97.7433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.151 hours/ns, 10.231 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.253     | 97.253     | 97.253     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075002   | 0.075002   | 0.075002   |   0.0 |  0.08
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.35805    | 0.35805    | 0.35805    |   0.0 |  0.37
Other   |            | 0.05683    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 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:      116866.0 ave      116866 max      116866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116866
Ave neighs/atom = 58.433000
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 = 333.184954546524, Press = -0.918362056293156
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   -8404.4806   -8404.4806   -8490.2216   -8490.2216    331.82656    331.82656    23707.816    23707.816    3759.2389    3759.2389 
   44000   -8404.0833   -8404.0833   -8491.0819   -8491.0819    336.69353    336.69353    23799.182    23799.182   -2660.7895   -2660.7895 
Loop time of 98.5165 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.366 hours/ns, 10.151 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.025     | 98.025     | 98.025     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074354   | 0.074354   | 0.074354   |   0.0 |  0.08
Output  | 0.00015553 | 0.00015553 | 0.00015553 |   0.0 |  0.00
Modify  | 0.36003    | 0.36003    | 0.36003    |   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:        2960.00 ave        2960 max        2960 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:      116918.0 ave      116918 max      116918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116918
Ave neighs/atom = 58.459000
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 = 333.223900044087, Press = -3.60457184271936
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   -8404.0833   -8404.0833   -8491.0819   -8491.0819    336.69353    336.69353    23799.182    23799.182   -2660.7895   -2660.7895 
   45000   -8401.1496   -8401.1496   -8487.8361   -8487.8361    335.48545    335.48545    23784.117    23784.117   -1182.8152   -1182.8152 
Loop time of 99.1773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.549 hours/ns, 10.083 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.68      | 98.68      | 98.68      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074926   | 0.074926   | 0.074926   |   0.0 |  0.08
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.36482    | 0.36482    | 0.36482    |   0.0 |  0.37
Other   |            | 0.05774    |            |       |  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:      116750.0 ave      116750 max      116750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116750
Ave neighs/atom = 58.375000
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 = 333.214408679394, Press = 0.653945235045892
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   -8401.1496   -8401.1496   -8487.8361   -8487.8361    335.48545    335.48545    23784.117    23784.117   -1182.8152   -1182.8152 
   46000   -8404.9828   -8404.9828   -8489.5779   -8489.5779    327.39153    327.39153    23740.194    23740.194    1547.0408    1547.0408 
Loop time of 99.4934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.637 hours/ns, 10.051 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.993     | 98.993     | 98.993     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076283   | 0.076283   | 0.076283   |   0.0 |  0.08
Output  | 0.00015364 | 0.00015364 | 0.00015364 |   0.0 |  0.00
Modify  | 0.36706    | 0.36706    | 0.36706    |   0.0 |  0.37
Other   |            | 0.05738    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 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:      116844.0 ave      116844 max      116844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116844
Ave neighs/atom = 58.422000
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 = 333.281497981771, Press = 0.342558046518955
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   -8404.9828   -8404.9828   -8489.5779   -8489.5779    327.39153    327.39153    23740.194    23740.194    1547.0408    1547.0408 
   47000   -8400.9206   -8400.9206   -8490.6119   -8490.6119     347.1144     347.1144    23765.082    23765.082   -371.24991   -371.24991 
Loop time of 99.0335 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.537     | 98.537     | 98.537     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075055   | 0.075055   | 0.075055   |   0.0 |  0.08
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.36379    | 0.36379    | 0.36379    |   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:        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:      116902.0 ave      116902 max      116902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116902
Ave neighs/atom = 58.451000
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 = 333.301329951197, Press = -1.57744195484754
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   -8400.9206   -8400.9206   -8490.6119   -8490.6119     347.1144     347.1144    23765.082    23765.082   -371.24991   -371.24991 
   48000   -8406.9613   -8406.9613   -8492.5113   -8492.5113    331.08755    331.08755    23799.735    23799.735   -3252.2566   -3252.2566 
Loop time of 98.652 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.156     | 98.156     | 98.156     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074899   | 0.074899   | 0.074899   |   0.0 |  0.08
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.36355    | 0.36355    | 0.36355    |   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:        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:      116818.0 ave      116818 max      116818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116818
Ave neighs/atom = 58.409000
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
23760.8713586083

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0