# 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_LeeBaskesKim_2001_Fe__MO_196726067688_000
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_196726067688_000#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.30945   -774.30945 
Loop time of 95.1245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.423 hours/ns, 10.513 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    | 94.651     | 94.651     | 94.651     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075408   | 0.075408   | 0.075408   |   0.0 |  0.08
Output  | 0.00019481 | 0.00019481 | 0.00019481 |   0.0 |  0.00
Modify  | 0.34266    | 0.34266    | 0.34266    |   0.0 |  0.36
Other   |            | 0.05554    |            |       |  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.30945   -774.30945 
    2000   -8404.1366   -8404.1366   -8488.8528   -8488.8528    327.86032    327.86032    23787.917    23787.917   -1855.3108   -1855.3108 
Loop time of 98.4173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.338 hours/ns, 10.161 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.943     | 97.943     | 97.943     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074958   | 0.074958   | 0.074958   |   0.0 |  0.08
Output  | 0.00019135 | 0.00019135 | 0.00019135 |   0.0 |  0.00
Modify  | 0.34295    | 0.34295    | 0.34295    |   0.0 |  0.35
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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.1026    1602.1026 
Loop time of 99.0347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.510 hours/ns, 10.097 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.554     | 98.554     | 98.554     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075835   | 0.075835   | 0.075835   |   0.0 |  0.08
Output  | 0.0001903  | 0.0001903  | 0.0001903  |   0.0 |  0.00
Modify  | 0.34829    | 0.34829    | 0.34829    |   0.0 |  0.35
Other   |            | 0.05651    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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.1026    1602.1026 
    4000   -8402.7949   -8402.7949   -8491.5321   -8491.5321    343.42246    343.42246    23735.915    23735.915    1545.7965    1545.7965 
Loop time of 98.8547 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.460 hours/ns, 10.116 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.377     | 98.377     | 98.377     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075205   | 0.075205   | 0.075205   |   0.0 |  0.08
Output  | 0.00019235 | 0.00019235 | 0.00019235 |   0.0 |  0.00
Modify  | 0.34588    | 0.34588    | 0.34588    |   0.0 |  0.35
Other   |            | 0.05675    |            |       |  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 98.7083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.419 hours/ns, 10.131 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.228     | 98.228     | 98.228     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075381   | 0.075381   | 0.075381   |   0.0 |  0.08
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.34793    | 0.34793    | 0.34793    |   0.0 |  0.35
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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.271763775915, Press = -406.186650542501
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.714826    -3.714826 
Loop time of 98.7555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.432 hours/ns, 10.126 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.262     | 98.262     | 98.262     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074739   | 0.074739   | 0.074739   |   0.0 |  0.08
Output  | 0.00019754 | 0.00019754 | 0.00019754 |   0.0 |  0.00
Modify  | 0.36219    | 0.36219    | 0.36219    |   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:        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.794216069768, Press = 13.0057091185343
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.714826    -3.714826 
    7000   -8404.0415   -8404.0415   -8490.7759   -8490.7759    335.67114    335.67114    23763.668    23763.668   -354.90256   -354.90256 
Loop time of 98.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.346 hours/ns, 10.158 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.952     | 97.952     | 97.952     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074809   | 0.074809   | 0.074809   |   0.0 |  0.08
Output  | 0.00015253 | 0.00015253 | 0.00015253 |   0.0 |  0.00
Modify  | 0.36202    | 0.36202    | 0.36202    |   0.0 |  0.37
Other   |            | 0.05624    |            |       |  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.874100218697, Press = -16.3591279590875
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.90256   -354.90256 
    8000   -8401.1428   -8401.1428   -8488.6013   -8488.6013    338.47347    338.47347    23787.589    23787.589    -1671.747    -1671.747 
Loop time of 98.4901 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.358 hours/ns, 10.153 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.995     | 97.995     | 97.995     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07527    | 0.07527    | 0.07527    |   0.0 |  0.08
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.36308    | 0.36308    | 0.36308    |   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:      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.88362652266, Press = 7.39981674215268
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.747    -1671.747 
    9000   -8405.1185   -8405.1185   -8487.9676   -8487.9676    320.63473    320.63473    23733.829    23733.829    2104.7597    2104.7597 
Loop time of 98.6405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.400 hours/ns, 10.138 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.145     | 98.145     | 98.145     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075544   | 0.075544   | 0.075544   |   0.0 |  0.08
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.3632     | 0.3632     | 0.3632     |   0.0 |  0.37
Other   |            | 0.05654    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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.864809584171, Press = 15.601145285059
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.63473    320.63473    23733.829    23733.829    2104.7597    2104.7597 
   10000   -8402.8072   -8402.8072    -8488.778    -8488.778    332.71611    332.71611    23733.922    23733.922    2009.2314    2009.2314 
Loop time of 98.3291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.314 hours/ns, 10.170 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.836     | 97.836     | 97.836     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075285   | 0.075285   | 0.075285   |   0.0 |  0.08
Output  | 0.00014973 | 0.00014973 | 0.00014973 |   0.0 |  0.00
Modify  | 0.36152    | 0.36152    | 0.36152    |   0.0 |  0.37
Other   |            | 0.05609    |            |       |  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.02073074053, Press = -14.2592577557598
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.71611    332.71611    23733.922    23733.922    2009.2314    2009.2314 
   11000   -8404.0109   -8404.0109   -8490.2925   -8490.2925    333.91902    333.91902     23802.37     23802.37   -3030.3302   -3030.3302 
Loop time of 99.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.605 hours/ns, 10.063 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.876     | 98.876     | 98.876     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076106   | 0.076106   | 0.076106   |   0.0 |  0.08
Output  | 0.00015145 | 0.00015145 | 0.00015145 |   0.0 |  0.00
Modify  | 0.36869    | 0.36869    | 0.36869    |   0.0 |  0.37
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:      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.110813314853, Press = -8.42948713572941
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.0109   -8404.0109   -8490.2925   -8490.2925    333.91902    333.91902     23802.37     23802.37   -3030.3302   -3030.3302 
   12000   -8408.5068   -8408.5068   -8492.4202   -8492.4202    324.75321    324.75321    23755.358    23755.358    -161.1891    -161.1891 
Loop time of 98.1173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.255 hours/ns, 10.192 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.625     | 97.625     | 97.625     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075228   | 0.075228   | 0.075228   |   0.0 |  0.08
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.36038    | 0.36038    | 0.36038    |   0.0 |  0.37
Other   |            | 0.05626    |            |       |  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.803432116878, Press = 8.9727026293363
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.5068   -8408.5068   -8492.4202   -8492.4202    324.75321    324.75321    23755.358    23755.358    -161.1891    -161.1891 
   13000   -8404.1211   -8404.1211   -8488.5911   -8488.5911    326.90801    326.90801    23742.672    23742.672     1447.417     1447.417 
Loop time of 97.9265 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.202 hours/ns, 10.212 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.436     | 97.436     | 97.436     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074662   | 0.074662   | 0.074662   |   0.0 |  0.08
Output  | 0.0001523  | 0.0001523  | 0.0001523  |   0.0 |  0.00
Modify  | 0.35913    | 0.35913    | 0.35913    |   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:        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.653362568319, Press = -1.73265022629236
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.1211   -8404.1211   -8488.5911   -8488.5911    326.90801    326.90801    23742.672    23742.672     1447.417     1447.417 
   14000   -8401.9249   -8401.9249   -8490.7103   -8490.7103    343.60868    343.60868    23776.695    23776.695   -1200.8258   -1200.8258 
Loop time of 98.2126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.281 hours/ns, 10.182 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.722     | 97.722     | 97.722     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07451    | 0.07451    | 0.07451    |   0.0 |  0.08
Output  | 0.00019574 | 0.00019574 | 0.00019574 |   0.0 |  0.00
Modify  | 0.35959    | 0.35959    | 0.35959    |   0.0 |  0.37
Other   |            | 0.05674    |            |       |  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.715189124754, Press = -3.97893587961402
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.9249   -8401.9249   -8490.7103   -8490.7103    343.60868    343.60868    23776.695    23776.695   -1200.8258   -1200.8258 
   15000   -8406.4899   -8406.4899   -8493.2835   -8493.2835    335.89992    335.89992    23770.836    23770.836   -1139.6996   -1139.6996 
Loop time of 98.4331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.343 hours/ns, 10.159 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.938     | 97.938     | 97.938     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075386   | 0.075386   | 0.075386   |   0.0 |  0.08
Output  | 0.00047429 | 0.00047429 | 0.00047429 |   0.0 |  0.00
Modify  | 0.3622     | 0.3622     | 0.3622     |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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.566961335409, Press = 1.04636432666001
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.4899   -8406.4899   -8493.2835   -8493.2835    335.89992    335.89992    23770.836    23770.836   -1139.6996   -1139.6996 
   16000   -8400.6733   -8400.6733   -8488.9026   -8488.9026    341.45654    341.45654    23722.561    23722.561    3070.1734    3070.1734 
Loop time of 97.8551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.182 hours/ns, 10.219 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.364     | 97.364     | 97.364     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075785   | 0.075785   | 0.075785   |   0.0 |  0.08
Output  | 0.00016792 | 0.00016792 | 0.00016792 |   0.0 |  0.00
Modify  | 0.35925    | 0.35925    | 0.35925    |   0.0 |  0.37
Other   |            | 0.05641    |            |       |  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.597794338178, Press = 5.08025437451675
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.6733   -8400.6733   -8488.9026   -8488.9026    341.45654    341.45654    23722.561    23722.561    3070.1734    3070.1734 
   17000   -8403.5049   -8403.5049   -8489.0025   -8489.0025    330.88433    330.88433    23736.058    23736.058    1859.3978    1859.3978 
Loop time of 99.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.642 hours/ns, 10.049 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.01      | 99.01      | 99.01      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076942   | 0.076942   | 0.076942   |   0.0 |  0.08
Output  | 0.00015632 | 0.00015632 | 0.00015632 |   0.0 |  0.00
Modify  | 0.3679     | 0.3679     | 0.3679     |   0.0 |  0.37
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:        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.674128713188, Press = -8.86186225978067
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   -8403.5049   -8403.5049   -8489.0025   -8489.0025    330.88433    330.88433    23736.058    23736.058    1859.3978    1859.3978 
   18000   -8403.7918   -8403.7918   -8490.9272   -8490.9272    337.22323    337.22323    23793.692    23793.692   -2541.0895   -2541.0895 
Loop time of 98.1436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.262 hours/ns, 10.189 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.649     | 97.649     | 97.649     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075596   | 0.075596   | 0.075596   |   0.0 |  0.08
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.362      | 0.362      | 0.362      |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2968.00 ave        2968 max        2968 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 = 332.68434810277, Press = -1.99940795679548
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   -8403.7918   -8403.7918   -8490.9272   -8490.9272    337.22323    337.22323    23793.692    23793.692   -2541.0895   -2541.0895 
   19000   -8402.6785   -8402.6785   -8488.6782   -8488.6782    332.82792    332.82792    23757.311    23757.311    372.76675    372.76675 
Loop time of 97.7422 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.251     | 97.251     | 97.251     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075229   | 0.075229   | 0.075229   |   0.0 |  0.08
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.35875    | 0.35875    | 0.35875    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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 = 332.620082047614, Press = 3.58558605594113
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   -8402.6785   -8402.6785   -8488.6782   -8488.6782    332.82792    332.82792    23757.311    23757.311    372.76675    372.76675 
   20000   -8401.4521   -8401.4521   -8490.0473   -8490.0473    342.87267    342.87267    23745.321    23745.321    1030.9406    1030.9406 
Loop time of 98.5572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.377 hours/ns, 10.146 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.063     | 98.063     | 98.063     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075633   | 0.075633   | 0.075633   |   0.0 |  0.08
Output  | 0.00018823 | 0.00018823 | 0.00018823 |   0.0 |  0.00
Modify  | 0.36216    | 0.36216    | 0.36216    |   0.0 |  0.37
Other   |            | 0.05625    |            |       |  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:      116858.0 ave      116858 max      116858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116858
Ave neighs/atom = 58.429000
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.558999389911, Press = -1.22423272509588
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   -8401.4521   -8401.4521   -8490.0473   -8490.0473    342.87267    342.87267    23745.321    23745.321    1030.9406    1030.9406 
   21000   -8408.6476   -8408.6476   -8491.6853   -8491.6853    321.36455    321.36455     23765.91     23765.91   -756.51482   -756.51482 
Loop time of 97.6236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.118 hours/ns, 10.243 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.133     | 97.133     | 97.133     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074863   | 0.074863   | 0.074863   |   0.0 |  0.08
Output  | 0.00015362 | 0.00015362 | 0.00015362 |   0.0 |  0.00
Modify  | 0.35975    | 0.35975    | 0.35975    |   0.0 |  0.37
Other   |            | 0.05622    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116980.0 ave      116980 max      116980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116980
Ave neighs/atom = 58.490000
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.546120593368, Press = -2.04183804991568
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   -8408.6476   -8408.6476   -8491.6853   -8491.6853    321.36455    321.36455     23765.91     23765.91   -756.51482   -756.51482 
   22000    -8402.457    -8402.457   -8490.4733   -8490.4733    340.63239    340.63239     23764.45     23764.45   -171.20319   -171.20319 
Loop time of 98.0222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.228 hours/ns, 10.202 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.528     | 97.528     | 97.528     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075465   | 0.075465   | 0.075465   |   0.0 |  0.08
Output  | 0.00015489 | 0.00015489 | 0.00015489 |   0.0 |  0.00
Modify  | 0.36186    | 0.36186    | 0.36186    |   0.0 |  0.37
Other   |            | 0.05631    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2968.00 ave        2968 max        2968 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:      116864.0 ave      116864 max      116864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116864
Ave neighs/atom = 58.432000
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.451850762171, Press = 2.08434411195869
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.457    -8402.457   -8490.4733   -8490.4733    340.63239    340.63239     23764.45     23764.45   -171.20319   -171.20319 
   23000   -8404.5403   -8404.5403   -8491.4256   -8491.4256     336.2548     336.2548    23730.245    23730.245    1948.5179    1948.5179 
Loop time of 98.7578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.433 hours/ns, 10.126 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.264     | 98.264     | 98.264     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074788   | 0.074788   | 0.074788   |   0.0 |  0.08
Output  | 0.00024387 | 0.00024387 | 0.00024387 |   0.0 |  0.00
Modify  | 0.36167    | 0.36167    | 0.36167    |   0.0 |  0.37
Other   |            | 0.05698    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116832.0 ave      116832 max      116832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116832
Ave neighs/atom = 58.416000
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.42643435485, Press = -1.14297477759755
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   -8404.5403   -8404.5403   -8491.4256   -8491.4256     336.2548     336.2548    23730.245    23730.245    1948.5179    1948.5179 
   24000   -8405.4394   -8405.4394   -8489.3872   -8489.3872    324.88659    324.88659    23779.138    23779.138   -1319.4583   -1319.4583 
Loop time of 98.4466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.346 hours/ns, 10.158 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.952     | 97.952     | 97.952     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075739   | 0.075739   | 0.075739   |   0.0 |  0.08
Output  | 0.0001526  | 0.0001526  | 0.0001526  |   0.0 |  0.00
Modify  | 0.36237    | 0.36237    | 0.36237    |   0.0 |  0.37
Other   |            | 0.05623    |            |       |  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:      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 = 332.378641014118, Press = -4.69349251278095
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   -8405.4394   -8405.4394   -8489.3872   -8489.3872    324.88659    324.88659    23779.138    23779.138   -1319.4583   -1319.4583 
   25000   -8401.7151   -8401.7151   -8487.6861   -8487.6861    332.71688    332.71688     23794.74     23794.74   -1900.2244   -1900.2244 
Loop time of 98.6262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.396 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.132     | 98.132     | 98.132     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074985   | 0.074985   | 0.074985   |   0.0 |  0.08
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.36185    | 0.36185    | 0.36185    |   0.0 |  0.37
Other   |            | 0.05686    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116776.0 ave      116776 max      116776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116776
Ave neighs/atom = 58.388000
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.318754886874, Press = 2.84686060286421
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   -8401.7151   -8401.7151   -8487.6861   -8487.6861    332.71688    332.71688     23794.74     23794.74   -1900.2244   -1900.2244 
   26000    -8406.841    -8406.841   -8492.7701   -8492.7701    332.55429    332.55429    23727.641    23727.641    1820.2913    1820.2913 
Loop time of 99.0519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.514 hours/ns, 10.096 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.553     | 98.553     | 98.553     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075577   | 0.075577   | 0.075577   |   0.0 |  0.08
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.36641    | 0.36641    | 0.36641    |   0.0 |  0.37
Other   |            | 0.05706    |            |       |  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:      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.299522036783, Press = 1.29702523316796
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    -8406.841    -8406.841   -8492.7701   -8492.7701    332.55429    332.55429    23727.641    23727.641    1820.2913    1820.2913 
   27000   -8404.5904   -8404.5904   -8489.6063   -8489.6063    329.02053    329.02053    23746.732    23746.732    976.91064    976.91064 
Loop time of 98.0656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.240 hours/ns, 10.197 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.574     | 97.574     | 97.574     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074829   | 0.074829   | 0.074829   |   0.0 |  0.08
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.36045    | 0.36045    | 0.36045    |   0.0 |  0.37
Other   |            | 0.05596    |            |       |  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:      116858.0 ave      116858 max      116858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116858
Ave neighs/atom = 58.429000
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.209137185352, Press = -2.27398758197719
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   -8404.5904   -8404.5904   -8489.6063   -8489.6063    329.02053    329.02053    23746.732    23746.732    976.91064    976.91064 
   28000    -8405.206    -8405.206   -8488.8792   -8488.8792    323.82389    323.82389    23769.585    23769.585   -596.05715   -596.05715 
Loop time of 97.5957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.110 hours/ns, 10.246 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.105     | 97.105     | 97.105     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074773   | 0.074773   | 0.074773   |   0.0 |  0.08
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.35927    | 0.35927    | 0.35927    |   0.0 |  0.37
Other   |            | 0.05629    |            |       |  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:      116928.0 ave      116928 max      116928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116928
Ave neighs/atom = 58.464000
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.207021443525, Press = -0.633075841857325
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    -8405.206    -8405.206   -8488.8792   -8488.8792    323.82389    323.82389    23769.585    23769.585   -596.05715   -596.05715 
   29000   -8405.1938   -8405.1938   -8489.1175   -8489.1175    324.79322    324.79322    23752.234    23752.234     734.0807     734.0807 
Loop time of 98.0201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.228 hours/ns, 10.202 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.524     | 97.524     | 97.524     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075639   | 0.075639   | 0.075639   |   0.0 |  0.08
Output  | 0.00014955 | 0.00014955 | 0.00014955 |   0.0 |  0.00
Modify  | 0.36303    | 0.36303    | 0.36303    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 332.094142012428, Press = 0.034932267730197
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   -8405.1938   -8405.1938   -8489.1175   -8489.1175    324.79322    324.79322    23752.234    23752.234     734.0807     734.0807 
   30000   -8405.9373   -8405.9373    -8491.514    -8491.514    331.19077    331.19077    23755.801    23755.801    10.833922    10.833922 
Loop time of 99.3768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.605 hours/ns, 10.063 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.877     | 98.877     | 98.877     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075835   | 0.075835   | 0.075835   |   0.0 |  0.08
Output  | 0.00014934 | 0.00014934 | 0.00014934 |   0.0 |  0.00
Modify  | 0.36716    | 0.36716    | 0.36716    |   0.0 |  0.37
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116792.0 ave      116792 max      116792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116792
Ave neighs/atom = 58.396000
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.106365335217, Press = -1.24161469077066
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   -8405.9373   -8405.9373    -8491.514    -8491.514    331.19077    331.19077    23755.801    23755.801    10.833922    10.833922 
   31000   -8403.0675   -8403.0675   -8487.7592   -8487.7592    327.76537    327.76537    23790.781    23790.781   -1789.0294   -1789.0294 
Loop time of 99.2963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.582 hours/ns, 10.071 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.798     | 98.798     | 98.798     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075808   | 0.075808   | 0.075808   |   0.0 |  0.08
Output  | 0.00020229 | 0.00020229 | 0.00020229 |   0.0 |  0.00
Modify  | 0.36583    | 0.36583    | 0.36583    |   0.0 |  0.37
Other   |            | 0.05677    |            |       |  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:      116832.0 ave      116832 max      116832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116832
Ave neighs/atom = 58.416000
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.12811635029, Press = -1.35726336754683
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   -8403.0675   -8403.0675   -8487.7592   -8487.7592    327.76537    327.76537    23790.781    23790.781   -1789.0294   -1789.0294 
   32000    -8406.851    -8406.851   -8492.6396   -8492.6396    332.01103    332.01103    23765.373    23765.373   -793.07746   -793.07746 
Loop time of 98.1311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.259 hours/ns, 10.190 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.637     | 97.637     | 97.637     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075646   | 0.075646   | 0.075646   |   0.0 |  0.08
Output  | 0.00021043 | 0.00021043 | 0.00021043 |   0.0 |  0.00
Modify  | 0.36212    | 0.36212    | 0.36212    |   0.0 |  0.37
Other   |            | 0.05655    |            |       |  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:      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.153697622712, Press = 3.88152493500799
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    -8406.851    -8406.851   -8492.6396   -8492.6396    332.01103    332.01103    23765.373    23765.373   -793.07746   -793.07746 
   33000   -8401.7894   -8401.7894   -8488.6498   -8488.6498    336.15852    336.15852     23712.51     23712.51    3653.2069    3653.2069 
Loop time of 98.2628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.295 hours/ns, 10.177 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.767     | 97.767     | 97.767     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076151   | 0.076151   | 0.076151   |   0.0 |  0.08
Output  | 0.00015244 | 0.00015244 | 0.00015244 |   0.0 |  0.00
Modify  | 0.36268    | 0.36268    | 0.36268    |   0.0 |  0.37
Other   |            | 0.05631    |            |       |  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:      116792.0 ave      116792 max      116792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116792
Ave neighs/atom = 58.396000
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.217938052892, Press = 0.10155282602063
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   -8401.7894   -8401.7894   -8488.6498   -8488.6498    336.15852    336.15852     23712.51     23712.51    3653.2069    3653.2069 
   34000   -8406.4581   -8406.4581   -8490.4043   -8490.4043    324.88039    324.88039    23753.008    23753.008    386.33709    386.33709 
Loop time of 98.8461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.457 hours/ns, 10.117 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.348     | 98.348     | 98.348     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076517   | 0.076517   | 0.076517   |   0.0 |  0.08
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.36489    | 0.36489    | 0.36489    |   0.0 |  0.37
Other   |            | 0.05685    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2981.00 ave        2981 max        2981 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:      117008.0 ave      117008 max      117008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 117008
Ave neighs/atom = 58.504000
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.282920822661, Press = -2.76280970747005
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   -8406.4581   -8406.4581   -8490.4043   -8490.4043    324.88039    324.88039    23753.008    23753.008    386.33709    386.33709 
   35000   -8401.9927   -8401.9927   -8489.0463   -8489.0463    336.90658    336.90658    23802.868    23802.868   -2765.5713   -2765.5713 
Loop time of 98.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.493 hours/ns, 10.104 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.475     | 98.475     | 98.475     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076067   | 0.076067   | 0.076067   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.36662    | 0.36662    | 0.36662    |   0.0 |  0.37
Other   |            | 0.05705    |            |       |  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:      116822.0 ave      116822 max      116822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116822
Ave neighs/atom = 58.411000
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.270070502229, Press = -0.683114229068128
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   -8401.9927   -8401.9927   -8489.0463   -8489.0463    336.90658    336.90658    23802.868    23802.868   -2765.5713   -2765.5713 
   36000    -8403.613    -8403.613    -8489.533    -8489.533    332.51946    332.51946    23751.595    23751.595     784.8951     784.8951 
Loop time of 98.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.367 hours/ns, 10.150 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.026     | 98.026     | 98.026     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07583    | 0.07583    | 0.07583    |   0.0 |  0.08
Output  | 0.00015679 | 0.00015679 | 0.00015679 |   0.0 |  0.00
Modify  | 0.36158    | 0.36158    | 0.36158    |   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:        2976.00 ave        2976 max        2976 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.223163207406, Press = 1.49105590847456
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    -8403.613    -8403.613    -8489.533    -8489.533    332.51946    332.51946    23751.595    23751.595     784.8951     784.8951 
   37000   -8405.2849   -8405.2849   -8488.3323   -8488.3323    321.40189    321.40189    23729.925    23729.925    2321.7498    2321.7498 
Loop time of 98.9505 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.486 hours/ns, 10.106 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.45      | 98.45      | 98.45      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075643   | 0.075643   | 0.075643   |   0.0 |  0.08
Output  | 0.0001579  | 0.0001579  | 0.0001579  |   0.0 |  0.00
Modify  | 0.36728    | 0.36728    | 0.36728    |   0.0 |  0.37
Other   |            | 0.05753    |            |       |  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:      116832.0 ave      116832 max      116832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116832
Ave neighs/atom = 58.416000
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.25443833178, Press = -1.29736742568725
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.2849   -8405.2849   -8488.3323   -8488.3323    321.40189    321.40189    23729.925    23729.925    2321.7498    2321.7498 
   38000   -8400.0402   -8400.0402   -8485.1867   -8485.1867    329.52548    329.52548    23820.615    23820.615   -3462.0309   -3462.0309 
Loop time of 97.4459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.068 hours/ns, 10.262 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.954     | 96.954     | 96.954     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074943   | 0.074943   | 0.074943   |   0.0 |  0.08
Output  | 0.00019791 | 0.00019791 | 0.00019791 |   0.0 |  0.00
Modify  | 0.35994    | 0.35994    | 0.35994    |   0.0 |  0.37
Other   |            | 0.05641    |            |       |  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:      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 = 332.331091488657, Press = -2.8153542552102
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   -8400.0402   -8400.0402   -8485.1867   -8485.1867    329.52548    329.52548    23820.615    23820.615   -3462.0309   -3462.0309 
   39000   -8406.2175   -8406.2175   -8489.3712   -8489.3712    321.81352    321.81352    23785.298    23785.298   -1730.1025   -1730.1025 
Loop time of 99.6591 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.683 hours/ns, 10.034 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.155     | 99.155     | 99.155     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076521   | 0.076521   | 0.076521   |   0.0 |  0.08
Output  | 0.00015779 | 0.00015779 | 0.00015779 |   0.0 |  0.00
Modify  | 0.37064    | 0.37064    | 0.37064    |   0.0 |  0.37
Other   |            | 0.05727    |            |       |  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:      116754.0 ave      116754 max      116754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116754
Ave neighs/atom = 58.377000
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.4263501851, Press = 3.11226202779556
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   -8406.2175   -8406.2175   -8489.3712   -8489.3712    321.81352    321.81352    23785.298    23785.298   -1730.1025   -1730.1025 
   40000   -8405.6197   -8405.6197   -8492.1438   -8492.1438     334.8574     334.8574    23722.902    23722.902    2404.1859    2404.1859 
Loop time of 98.5307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.370 hours/ns, 10.149 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.035     | 98.035     | 98.035     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074843   | 0.074843   | 0.074843   |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.36418    | 0.36418    | 0.36418    |   0.0 |  0.37
Other   |            | 0.05695    |            |       |  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:      116762.0 ave      116762 max      116762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116762
Ave neighs/atom = 58.381000
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.433376333161, Press = 0.341413686891756
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   -8405.6197   -8405.6197   -8492.1438   -8492.1438     334.8574     334.8574    23722.902    23722.902    2404.1859    2404.1859 
   41000   -8406.6218   -8406.6218    -8492.019    -8492.019    330.49615    330.49615    23759.118    23759.118   -313.67688   -313.67688 
Loop time of 98.9431 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.446     | 98.446     | 98.446     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075681   | 0.075681   | 0.075681   |   0.0 |  0.08
Output  | 0.00038009 | 0.00038009 | 0.00038009 |   0.0 |  0.00
Modify  | 0.36451    | 0.36451    | 0.36451    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 332.460445170472, Press = -1.85863208733208
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   -8406.6218   -8406.6218    -8492.019    -8492.019    330.49615    330.49615    23759.118    23759.118   -313.67688   -313.67688 
   42000   -8404.1957   -8404.1957    -8489.267    -8489.267    329.23463    329.23463    23788.889    23788.889   -1815.4376   -1815.4376 
Loop time of 98.0373 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.233 hours/ns, 10.200 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.543     | 97.543     | 97.543     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075313   | 0.075313   | 0.075313   |   0.0 |  0.08
Output  | 0.00015291 | 0.00015291 | 0.00015291 |   0.0 |  0.00
Modify  | 0.36231    | 0.36231    | 0.36231    |   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:        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:      116850.0 ave      116850 max      116850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116850
Ave neighs/atom = 58.425000
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.392076631864, Press = 0.113225917469968
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.1957   -8404.1957    -8489.267    -8489.267    329.23463    329.23463    23788.889    23788.889   -1815.4376   -1815.4376 
   43000   -8407.1061   -8407.1061   -8491.7075   -8491.7075    327.41612    327.41612    23740.271    23740.271    1147.9399    1147.9399 
Loop time of 98.1192 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.255 hours/ns, 10.192 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.624     | 97.624     | 97.624     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075119   | 0.075119   | 0.075119   |   0.0 |  0.08
Output  | 0.00016587 | 0.00016587 | 0.00016587 |   0.0 |  0.00
Modify  | 0.36367    | 0.36367    | 0.36367    |   0.0 |  0.37
Other   |            | 0.05666    |            |       |  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:      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 = 332.39338364372, Press = 1.77132961298832
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   -8407.1061   -8407.1061   -8491.7075   -8491.7075    327.41612    327.41612    23740.271    23740.271    1147.9399    1147.9399 
   44000   -8401.1573   -8401.1573    -8488.088    -8488.088    336.43053    336.43053    23707.735    23707.735    4276.4332    4276.4332 
Loop time of 98.0127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.226 hours/ns, 10.203 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.524     | 97.524     | 97.524     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074105   | 0.074105   | 0.074105   |   0.0 |  0.08
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.35758    | 0.35758    | 0.35758    |   0.0 |  0.36
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116788.0 ave      116788 max      116788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116788
Ave neighs/atom = 58.394000
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.377725735955, Press = -1.68161976809421
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   -8401.1573   -8401.1573    -8488.088    -8488.088    336.43053    336.43053    23707.735    23707.735    4276.4332    4276.4332 
   45000   -8405.9238   -8405.9238   -8488.7253   -8488.7253     320.4504     320.4504    23790.907    23790.907   -1987.4034   -1987.4034 
Loop time of 97.865 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.185 hours/ns, 10.218 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.374     | 97.374     | 97.374     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075139   | 0.075139   | 0.075139   |   0.0 |  0.08
Output  | 0.0002023  | 0.0002023  | 0.0002023  |   0.0 |  0.00
Modify  | 0.35934    | 0.35934    | 0.35934    |   0.0 |  0.37
Other   |            | 0.05648    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 332.40623775569, Press = -1.39899522063669
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   -8405.9238   -8405.9238   -8488.7253   -8488.7253     320.4504     320.4504    23790.907    23790.907   -1987.4034   -1987.4034 
   46000   -8398.6369   -8398.6369   -8487.8634   -8487.8634    345.31574    345.31574    23779.026    23779.026   -732.58463   -732.58463 
Loop time of 99.1758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.549 hours/ns, 10.083 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.677     | 98.677     | 98.677     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07615    | 0.07615    | 0.07615    |   0.0 |  0.08
Output  | 0.00015878 | 0.00015878 | 0.00015878 |   0.0 |  0.00
Modify  | 0.36527    | 0.36527    | 0.36527    |   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:        2982.00 ave        2982 max        2982 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:      116822.0 ave      116822 max      116822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116822
Ave neighs/atom = 58.411000
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.475494974159, Press = 1.08618820086104
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   -8398.6369   -8398.6369   -8487.8634   -8487.8634    345.31574    345.31574    23779.026    23779.026   -732.58463   -732.58463 
   47000   -8404.9581   -8404.9581   -8491.2746   -8491.2746    334.05353    334.05353    23730.942    23730.942    1844.4862    1844.4862 
Loop time of 97.4164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.060 hours/ns, 10.265 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.924     | 96.924     | 96.924     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075152   | 0.075152   | 0.075152   |   0.0 |  0.08
Output  | 0.00015638 | 0.00015638 | 0.00015638 |   0.0 |  0.00
Modify  | 0.36095    | 0.36095    | 0.36095    |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 332.528857563092, Press = 0.0731901797701286
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   -8404.9581   -8404.9581   -8491.2746   -8491.2746    334.05353    334.05353    23730.942    23730.942    1844.4862    1844.4862 
   48000   -8402.7652   -8402.7652   -8487.8529   -8487.8529    329.29843    329.29843    23767.362    23767.362   -73.878628   -73.878628 
Loop time of 98.6711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.409 hours/ns, 10.135 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.176     | 98.176     | 98.176     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075303   | 0.075303   | 0.075303   |   0.0 |  0.08
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.36344    | 0.36344    | 0.36344    |   0.0 |  0.37
Other   |            | 0.05665    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 332.581612624959, Press = -1.94659344130798
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8402.7652   -8402.7652   -8487.8529   -8487.8529    329.29843    329.29843    23767.362    23767.362   -73.878628   -73.878628 
   49000   -8406.3997   -8406.3997    -8491.073    -8491.073    327.69444    327.69444    23797.872    23797.872    -2852.999    -2852.999 
Loop time of 98.1255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.257 hours/ns, 10.191 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.632     | 97.632     | 97.632     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075427   | 0.075427   | 0.075427   |   0.0 |  0.08
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.36169    | 0.36169    | 0.36169    |   0.0 |  0.37
Other   |            | 0.05644    |            |       |  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:      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"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.585936309935, Press = 0.702728830142193
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 
   49000   -8406.3997   -8406.3997    -8491.073    -8491.073    327.69444    327.69444    23797.872    23797.872    -2852.999    -2852.999 
   50000   -8403.7243   -8403.7243   -8490.1984   -8490.1984    334.66376    334.66376    23737.981    23737.981    1683.4317    1683.4317 
Loop time of 97.6554 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.127 hours/ns, 10.240 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.167     | 97.167     | 97.167     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074973   | 0.074973   | 0.074973   |   0.0 |  0.08
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.35701    | 0.35701    | 0.35701    |   0.0 |  0.37
Other   |            | 0.05632    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116730.0 ave      116730 max      116730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116730
Ave neighs/atom = 58.365000
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.58383972871, Press = 1.49359076840038
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 
   50000   -8403.7243   -8403.7243   -8490.1984   -8490.1984    334.66376    334.66376    23737.981    23737.981    1683.4317    1683.4317 
   51000   -8405.4281   -8405.4281   -8492.1109   -8492.1109    335.47145    335.47145    23740.518    23740.518    1130.7515    1130.7515 
Loop time of 98.3186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.311 hours/ns, 10.171 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.824     | 97.824     | 97.824     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074941   | 0.074941   | 0.074941   |   0.0 |  0.08
Output  | 0.0001965  | 0.0001965  | 0.0001965  |   0.0 |  0.00
Modify  | 0.36281    | 0.36281    | 0.36281    |   0.0 |  0.37
Other   |            | 0.05651    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 332.604592100898, Press = -0.880440402233597
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 
   51000   -8405.4281   -8405.4281   -8492.1109   -8492.1109    335.47145    335.47145    23740.518    23740.518    1130.7515    1130.7515 
   52000   -8402.9953   -8402.9953   -8491.3553   -8491.3553    341.96237    341.96237    23787.758    23787.758   -2060.1828   -2060.1828 
Loop time of 98.3251 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.313 hours/ns, 10.170 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.828     | 97.828     | 97.828     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075356   | 0.075356   | 0.075356   |   0.0 |  0.08
Output  | 0.00015156 | 0.00015156 | 0.00015156 |   0.0 |  0.00
Modify  | 0.36427    | 0.36427    | 0.36427    |   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:      116820.0 ave      116820 max      116820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116820
Ave neighs/atom = 58.410000
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.675954346504, Press = -0.223441342695584
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 
   52000   -8402.9953   -8402.9953   -8491.3553   -8491.3553    341.96237    341.96237    23787.758    23787.758   -2060.1828   -2060.1828 
   53000   -8401.9311   -8401.9311    -8489.761    -8489.761    339.91047    339.91047    23755.363    23755.363    652.35136    652.35136 
Loop time of 97.9757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.215 hours/ns, 10.207 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.485     | 97.485     | 97.485     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074931   | 0.074931   | 0.074931   |   0.0 |  0.08
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.35879    | 0.35879    | 0.35879    |   0.0 |  0.37
Other   |            | 0.05636    |            |       |  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:      116782.0 ave      116782 max      116782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116782
Ave neighs/atom = 58.391000
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.714718598725, Press = 0.994227902547312
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 
   53000   -8401.9311   -8401.9311    -8489.761    -8489.761    339.91047    339.91047    23755.363    23755.363    652.35136    652.35136 
   54000   -8406.4231   -8406.4231   -8489.8286   -8489.8286    322.78784    322.78784    23745.442    23745.442    991.17894    991.17894 
Loop time of 98.8432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.456 hours/ns, 10.117 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.342     | 98.342     | 98.342     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075786   | 0.075786   | 0.075786   |   0.0 |  0.08
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.36763    | 0.36763    | 0.36763    |   0.0 |  0.37
Other   |            | 0.05721    |            |       |  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:      116880.0 ave      116880 max      116880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116880
Ave neighs/atom = 58.440000
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.776863307373, Press = -0.191342691961734
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 
   54000   -8406.4231   -8406.4231   -8489.8286   -8489.8286    322.78784    322.78784    23745.442    23745.442    991.17894    991.17894 
   55000   -8402.9889   -8402.9889   -8487.2684   -8487.2684    326.17023    326.17023    23773.498    23773.498   -450.15832   -450.15832 
Loop time of 98.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.304 hours/ns, 10.174 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.799     | 97.799     | 97.799     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075468   | 0.075468   | 0.075468   |   0.0 |  0.08
Output  | 0.00015706 | 0.00015706 | 0.00015706 |   0.0 |  0.00
Modify  | 0.36213    | 0.36213    | 0.36213    |   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:        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:      116822.0 ave      116822 max      116822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116822
Ave neighs/atom = 58.411000
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.792393251102, Press = -0.717472818817612
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 
   55000   -8402.9889   -8402.9889   -8487.2684   -8487.2684    326.17023    326.17023    23773.498    23773.498   -450.15832   -450.15832 
   56000   -8404.3811   -8404.3811   -8491.7014   -8491.7014    337.93883    337.93883    23782.879    23782.879   -1832.7557   -1832.7557 
Loop time of 98.4674 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.352 hours/ns, 10.156 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.972     | 97.972     | 97.972     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076116   | 0.076116   | 0.076116   |   0.0 |  0.08
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.36226    | 0.36226    | 0.36226    |   0.0 |  0.37
Other   |            | 0.05643    |            |       |  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:      116878.0 ave      116878 max      116878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116878
Ave neighs/atom = 58.439000
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.817317314014, Press = 0.83238430359133
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 
   56000   -8404.3811   -8404.3811   -8491.7014   -8491.7014    337.93883    337.93883    23782.879    23782.879   -1832.7557   -1832.7557 
   57000   -8400.5318   -8400.5318   -8489.3978   -8489.3978    343.92046    343.92046    23706.385    23706.385    4125.1474    4125.1474 
Loop time of 98.7248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.424 hours/ns, 10.129 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.229     | 98.229     | 98.229     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075307   | 0.075307   | 0.075307   |   0.0 |  0.08
Output  | 0.00015334 | 0.00015334 | 0.00015334 |   0.0 |  0.00
Modify  | 0.36392    | 0.36392    | 0.36392    |   0.0 |  0.37
Other   |            | 0.05676    |            |       |  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:      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.890346032854, Press = 0.799191599340079
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 
   57000   -8400.5318   -8400.5318   -8489.3978   -8489.3978    343.92046    343.92046    23706.385    23706.385    4125.1474    4125.1474 
   58000   -8403.2633   -8403.2633   -8491.0881   -8491.0881     339.8907     339.8907    23772.335    23772.335   -837.92684   -837.92684 
Loop time of 98.0825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.245 hours/ns, 10.196 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.589     | 97.589     | 97.589     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07596    | 0.07596    | 0.07596    |   0.0 |  0.08
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.36034    | 0.36034    | 0.36034    |   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:        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:      116928.0 ave      116928 max      116928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116928
Ave neighs/atom = 58.464000
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.939070753824, Press = -1.77230533714365
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 
   58000   -8403.2633   -8403.2633   -8491.0881   -8491.0881     339.8907     339.8907    23772.335    23772.335   -837.92684   -837.92684 
   59000   -8402.5624   -8402.5624   -8488.4899   -8488.4899    332.54825    332.54825    23784.718    23784.718   -1345.7636   -1345.7636 
Loop time of 98.8848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.468 hours/ns, 10.113 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.389     | 98.389     | 98.389     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075369   | 0.075369   | 0.075369   |   0.0 |  0.08
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.36407    | 0.36407    | 0.36407    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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 = 332.965209072058, Press = 0.235771705916611
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 
   59000   -8402.5624   -8402.5624   -8488.4899   -8488.4899    332.54825    332.54825    23784.718    23784.718   -1345.7636   -1345.7636 
   60000   -8400.7692   -8400.7692   -8490.4792   -8490.4792    347.18669    347.18669    23763.815    23763.815   -6.5944811   -6.5944811 
Loop time of 98.3596 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.322 hours/ns, 10.167 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.865     | 97.865     | 97.865     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076083   | 0.076083   | 0.076083   |   0.0 |  0.08
Output  | 0.00020573 | 0.00020573 | 0.00020573 |   0.0 |  0.00
Modify  | 0.36179    | 0.36179    | 0.36179    |   0.0 |  0.37
Other   |            | 0.05694    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.048465999581, Press = 0.473792407851123
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 
   60000   -8400.7692   -8400.7692   -8490.4792   -8490.4792    347.18669    347.18669    23763.815    23763.815   -6.5944811   -6.5944811 
   61000   -8403.5866   -8403.5866   -8490.4883   -8490.4883    336.31846    336.31846    23752.646    23752.646    656.60364    656.60364 
Loop time of 98.1972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.277 hours/ns, 10.184 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.703     | 97.703     | 97.703     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074837   | 0.074837   | 0.074837   |   0.0 |  0.08
Output  | 0.00015342 | 0.00015342 | 0.00015342 |   0.0 |  0.00
Modify  | 0.36198    | 0.36198    | 0.36198    |   0.0 |  0.37
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116798.0 ave      116798 max      116798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116798
Ave neighs/atom = 58.399000
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.057958506609, Press = -0.202239153727309
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 
   61000   -8403.5866   -8403.5866   -8490.4883   -8490.4883    336.31846    336.31846    23752.646    23752.646    656.60364    656.60364 
   62000   -8405.2714   -8405.2714   -8490.8401   -8490.8401     331.1597     331.1597    23784.764    23784.764   -1800.9824   -1800.9824 
Loop time of 98.1585 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.266 hours/ns, 10.188 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.666     | 97.666     | 97.666     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075048   | 0.075048   | 0.075048   |   0.0 |  0.08
Output  | 0.00015209 | 0.00015209 | 0.00015209 |   0.0 |  0.00
Modify  | 0.36097    | 0.36097    | 0.36097    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116836.0 ave      116836 max      116836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116836
Ave neighs/atom = 58.418000
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.063795295646, Press = -0.45569301288137
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 
   62000   -8405.2714   -8405.2714   -8490.8401   -8490.8401     331.1597     331.1597    23784.764    23784.764   -1800.9824   -1800.9824 
   63000   -8402.3075   -8402.3075   -8488.5659   -8488.5659     333.8291     333.8291    23767.503    23767.503   -119.77236   -119.77236 
Loop time of 97.8783 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.188 hours/ns, 10.217 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.386     | 97.386     | 97.386     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07535    | 0.07535    | 0.07535    |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36056    | 0.36056    | 0.36056    |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2968.00 ave        2968 max        2968 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:      116736.0 ave      116736 max      116736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116736
Ave neighs/atom = 58.368000
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.017537638474, Press = 1.38346423292411
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 
   63000   -8402.3075   -8402.3075   -8488.5659   -8488.5659     333.8291     333.8291    23767.503    23767.503   -119.77236   -119.77236 
   64000   -8404.9996   -8404.9996   -8491.5657   -8491.5657    335.01975    335.01975    23710.648    23710.648     3303.951     3303.951 
Loop time of 98.5432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.373 hours/ns, 10.148 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.048     | 98.048     | 98.048     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075149   | 0.075149   | 0.075149   |   0.0 |  0.08
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.3636     | 0.3636     | 0.3636     |   0.0 |  0.37
Other   |            | 0.05648    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116870.0 ave      116870 max      116870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116870
Ave neighs/atom = 58.435000
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.022204953028, Press = -0.364201391846701
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 
   64000   -8404.9996   -8404.9996   -8491.5657   -8491.5657    335.01975    335.01975    23710.648    23710.648     3303.951     3303.951 
   65000   -8403.0997   -8403.0997   -8490.7129   -8490.7129    339.07222    339.07222    23780.675    23780.675   -1521.0062   -1521.0062 
Loop time of 99.2412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.567 hours/ns, 10.076 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.743     | 98.743     | 98.743     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075556   | 0.075556   | 0.075556   |   0.0 |  0.08
Output  | 0.00018934 | 0.00018934 | 0.00018934 |   0.0 |  0.00
Modify  | 0.36599    | 0.36599    | 0.36599    |   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:        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:      116886.0 ave      116886 max      116886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116886
Ave neighs/atom = 58.443000
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.042684834951, Press = -1.02075085536479
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 
   65000   -8403.0997   -8403.0997   -8490.7129   -8490.7129    339.07222    339.07222    23780.675    23780.675   -1521.0062   -1521.0062 
   66000   -8401.2494   -8401.2494   -8489.4351   -8489.4351    341.28757    341.28757    23788.087    23788.087   -1641.6191   -1641.6191 
Loop time of 99.6241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.673 hours/ns, 10.038 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.124     | 99.124     | 99.124     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075637   | 0.075637   | 0.075637   |   0.0 |  0.08
Output  | 0.00018385 | 0.00018385 | 0.00018385 |   0.0 |  0.00
Modify  | 0.36759    | 0.36759    | 0.36759    |   0.0 |  0.37
Other   |            | 0.0568     |            |       |  0.06

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

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.082285216235, Press = 0.443060868630653
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 
   66000   -8401.2494   -8401.2494   -8489.4351   -8489.4351    341.28757    341.28757    23788.087    23788.087   -1641.6191   -1641.6191 
   67000   -8406.4772   -8406.4772   -8492.1065   -8492.1065     331.3939     331.3939    23744.546    23744.546    809.80572    809.80572 
Loop time of 99.5175 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.644 hours/ns, 10.048 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.016     | 99.016     | 99.016     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075555   | 0.075555   | 0.075555   |   0.0 |  0.08
Output  | 0.00038401 | 0.00038401 | 0.00038401 |   0.0 |  0.00
Modify  | 0.36758    | 0.36758    | 0.36758    |   0.0 |  0.37
Other   |            | 0.05764    |            |       |  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:      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 = 333.082432696735, Press = 0.485526903153683
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 
   67000   -8406.4772   -8406.4772   -8492.1065   -8492.1065     331.3939     331.3939    23744.546    23744.546    809.80572    809.80572 
   68000   -8403.0697   -8403.0697   -8488.8915   -8488.8915    332.13935    332.13935    23753.159    23753.159    993.80831    993.80831 
Loop time of 98.1111 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.253 hours/ns, 10.193 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.619     | 97.619     | 97.619     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075392   | 0.075392   | 0.075392   |   0.0 |  0.08
Output  | 0.00015266 | 0.00015266 | 0.00015266 |   0.0 |  0.00
Modify  | 0.35972    | 0.35972    | 0.35972    |   0.0 |  0.37
Other   |            | 0.05653    |            |       |  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:      116812.0 ave      116812 max      116812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116812
Ave neighs/atom = 58.406000
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.09048946372, Press = -0.399683282210344
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 
   68000   -8403.0697   -8403.0697   -8488.8915   -8488.8915    332.13935    332.13935    23753.159    23753.159    993.80831    993.80831 
   69000   -8401.3202   -8401.3202   -8488.3272   -8488.3272    336.72615    336.72615    23779.446    23779.446   -1111.9611   -1111.9611 
Loop time of 98.7807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.439 hours/ns, 10.123 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.28      | 98.28      | 98.28      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075575   | 0.075575   | 0.075575   |   0.0 |  0.08
Output  | 0.00015151 | 0.00015151 | 0.00015151 |   0.0 |  0.00
Modify  | 0.36802    | 0.36802    | 0.36802    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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 = 333.098000188513, Press = -0.225248220009722
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 
   69000   -8401.3202   -8401.3202   -8488.3272   -8488.3272    336.72615    336.72615    23779.446    23779.446   -1111.9611   -1111.9611 
   70000   -8404.6417   -8404.6417    -8490.237    -8490.237    331.26254    331.26254    23757.404    23757.404    303.96743    303.96743 
Loop time of 98.2405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.289 hours/ns, 10.179 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.747     | 97.747     | 97.747     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074938   | 0.074938   | 0.074938   |   0.0 |  0.08
Output  | 0.0001595  | 0.0001595  | 0.0001595  |   0.0 |  0.00
Modify  | 0.36212    | 0.36212    | 0.36212    |   0.0 |  0.37
Other   |            | 0.05662    |            |       |  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:      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.098671121792, Press = 0.578889340207638
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 
   70000   -8404.6417   -8404.6417    -8490.237    -8490.237    331.26254    331.26254    23757.404    23757.404    303.96743    303.96743 
   71000   -8399.3859   -8399.3859   -8488.4794   -8488.4794     344.8009     344.8009    23735.754    23735.754    2196.2094    2196.2094 
Loop time of 98.8161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.449 hours/ns, 10.120 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.318     | 98.318     | 98.318     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075436   | 0.075436   | 0.075436   |   0.0 |  0.08
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.36556    | 0.36556    | 0.36556    |   0.0 |  0.37
Other   |            | 0.05698    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116742.0 ave      116742 max      116742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116742
Ave neighs/atom = 58.371000
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.12824265443, Press = -0.29620236056302
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 
   71000   -8399.3859   -8399.3859   -8488.4794   -8488.4794     344.8009     344.8009    23735.754    23735.754    2196.2094    2196.2094 
   72000   -8406.2109   -8406.2109   -8489.7889   -8489.7889    323.45575    323.45575     23777.09     23777.09   -1213.6454   -1213.6454 
Loop time of 99.0951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.526 hours/ns, 10.091 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.597     | 98.597     | 98.597     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075935   | 0.075935   | 0.075935   |   0.0 |  0.08
Output  | 0.00020181 | 0.00020181 | 0.00020181 |   0.0 |  0.00
Modify  | 0.36535    | 0.36535    | 0.36535    |   0.0 |  0.37
Other   |            | 0.05686    |            |       |  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:      116900.0 ave      116900 max      116900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116900
Ave neighs/atom = 58.450000
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.160392112682, Press = -1.40734985916923
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 
   72000   -8406.2109   -8406.2109   -8489.7889   -8489.7889    323.45575    323.45575     23777.09     23777.09   -1213.6454   -1213.6454 
   73000   -8406.7199   -8406.7199   -8490.1232   -8490.1232    322.77936    322.77936    23784.529    23784.529   -1920.5241   -1920.5241 
Loop time of 98.2609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.295 hours/ns, 10.177 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.768     | 97.768     | 97.768     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075835   | 0.075835   | 0.075835   |   0.0 |  0.08
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.36112    | 0.36112    | 0.36112    |   0.0 |  0.37
Other   |            | 0.05627    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2979.00 ave        2979 max        2979 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:      116870.0 ave      116870 max      116870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116870
Ave neighs/atom = 58.435000
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.152443710498, Press = 0.650560683616465
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 
   73000   -8406.7199   -8406.7199   -8490.1232   -8490.1232    322.77936    322.77936    23784.529    23784.529   -1920.5241   -1920.5241 
   74000   -8404.5945   -8404.5945   -8489.6634   -8489.6634    329.22519    329.22519    23740.249    23740.249     1531.562     1531.562 
Loop time of 98.9721 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.492 hours/ns, 10.104 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.473     | 98.473     | 98.473     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075412   | 0.075412   | 0.075412   |   0.0 |  0.08
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.36635    | 0.36635    | 0.36635    |   0.0 |  0.37
Other   |            | 0.0573     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      116732.0 ave      116732 max      116732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116732
Ave neighs/atom = 58.366000
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.12052821858, Press = 0.272240301577053
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 
   74000   -8404.5945   -8404.5945   -8489.6634   -8489.6634    329.22519    329.22519    23740.249    23740.249     1531.562     1531.562 
   75000   -8405.6822   -8405.6822   -8489.0535   -8489.0535    322.65545    322.65545     23756.59     23756.59    401.14881    401.14881 
Loop time of 98.6445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.401 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.145     | 98.145     | 98.145     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075691   | 0.075691   | 0.075691   |   0.0 |  0.08
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.3667     | 0.3667     | 0.3667     |   0.0 |  0.37
Other   |            | 0.05704    |            |       |  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:      116872.0 ave      116872 max      116872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116872
Ave neighs/atom = 58.436000
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.14406796326, Press = -0.553685307484883
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 
   75000   -8405.6822   -8405.6822   -8489.0535   -8489.0535    322.65545    322.65545     23756.59     23756.59    401.14881    401.14881 
   76000   -8404.3654   -8404.3654   -8491.1897   -8491.1897     336.0191     336.0191     23773.59     23773.59   -1064.8171   -1064.8171 
Loop time of 99.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.565 hours/ns, 10.077 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.734     | 98.734     | 98.734     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075537   | 0.075537   | 0.075537   |   0.0 |  0.08
Output  | 0.00015632 | 0.00015632 | 0.00015632 |   0.0 |  0.00
Modify  | 0.36649    | 0.36649    | 0.36649    |   0.0 |  0.37
Other   |            | 0.05696    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116878.0 ave      116878 max      116878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116878
Ave neighs/atom = 58.439000
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.14390185976, Press = -0.255570858564049
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 
   76000   -8404.3654   -8404.3654   -8491.1897   -8491.1897     336.0191     336.0191     23773.59     23773.59   -1064.8171   -1064.8171 
   77000   -8401.7733   -8401.7733   -8489.9626   -8489.9626    341.30185    341.30185    23765.063    23765.063   -264.47788   -264.47788 
Loop time of 99.2115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.559 hours/ns, 10.079 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.713     | 98.713     | 98.713     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07617    | 0.07617    | 0.07617    |   0.0 |  0.08
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.36497    | 0.36497    | 0.36497    |   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:        2971.00 ave        2971 max        2971 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:      116870.0 ave      116870 max      116870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116870
Ave neighs/atom = 58.435000
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.144103191723, Press = 0.394607636941239
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 
   77000   -8401.7733   -8401.7733   -8489.9626   -8489.9626    341.30185    341.30185    23765.063    23765.063   -264.47788   -264.47788 
   78000   -8402.2789   -8402.2789   -8490.8346   -8490.8346    342.71939    342.71939    23733.218    23733.218    1885.4291    1885.4291 
Loop time of 98.5552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.376 hours/ns, 10.147 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.06      | 98.06      | 98.06      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075451   | 0.075451   | 0.075451   |   0.0 |  0.08
Output  | 0.00016281 | 0.00016281 | 0.00016281 |   0.0 |  0.00
Modify  | 0.36316    | 0.36316    | 0.36316    |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      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"
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
23761.1397341908

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0