# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.863657340407371*${_u_distance}
variable latticeconst_converted equal 2.863657340407371*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365734040737
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.636573 28.636573 28.636573)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.636573 28.636573 28.636573)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_856956178669_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8493.9171   -8493.9171        -8580        -8580       333.15       333.15    23483.518    23483.518    3915.3602    3915.3602 
    1000   -8403.2191   -8403.2191   -8485.7345   -8485.7345    319.34322    319.34322    23777.874    23777.874   -774.30946   -774.30946 
Loop time of 96.0921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.692 hours/ns, 10.407 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    | 95.609     | 95.609     | 95.609     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074084   | 0.074084   | 0.074084   |   0.0 |  0.08
Output  | 0.00019157 | 0.00019157 | 0.00019157 |   0.0 |  0.00
Modify  | 0.35199    | 0.35199    | 0.35199    |   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:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8403.2191   -8403.2191   -8485.7345   -8485.7345    319.34322    319.34322    23777.874    23777.874   -774.30946   -774.30946 
    2000   -8404.1366   -8404.1366   -8488.8528   -8488.8528    327.86032    327.86032    23787.917    23787.917   -1855.3108   -1855.3108 
Loop time of 101.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.124 hours/ns, 9.877 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.75     | 100.75     | 100.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076232   | 0.076232   | 0.076232   |   0.0 |  0.08
Output  | 0.00019065 | 0.00019065 | 0.00019065 |   0.0 |  0.00
Modify  | 0.35991    | 0.35991    | 0.35991    |   0.0 |  0.36
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:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116986.0 ave      116986 max      116986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116986
Ave neighs/atom = 58.493000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8404.1366   -8404.1366   -8488.8528   -8488.8528    327.86032    327.86032    23787.917    23787.917   -1855.3108   -1855.3108 
    3000   -8405.2295   -8405.2295   -8486.2363   -8486.2363    313.50468    313.50468    23742.799    23742.799    1602.1027    1602.1027 
Loop time of 99.528 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.647 hours/ns, 10.047 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.048     | 99.048     | 99.048     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074338   | 0.074338   | 0.074338   |   0.0 |  0.07
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.34793    | 0.34793    | 0.34793    |   0.0 |  0.35
Other   |            | 0.05735    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116824.0 ave      116824 max      116824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116824
Ave neighs/atom = 58.412000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8405.2295   -8405.2295   -8486.2363   -8486.2363    313.50468    313.50468    23742.799    23742.799    1602.1027    1602.1027 
    4000   -8402.7949   -8402.7949   -8491.5321   -8491.5321    343.42246    343.42246    23735.915    23735.915    1545.7965    1545.7965 
Loop time of 100.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.985 hours/ns, 9.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.26     | 100.26     | 100.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075649   | 0.075649   | 0.075649   |   0.0 |  0.08
Output  | 0.00018891 | 0.00018891 | 0.00018891 |   0.0 |  0.00
Modify  | 0.35506    | 0.35506    | 0.35506    |   0.0 |  0.35
Other   |            | 0.05757    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116906.0 ave      116906 max      116906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116906
Ave neighs/atom = 58.453000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8402.7949   -8402.7949   -8491.5321   -8491.5321    343.42246    343.42246    23735.915    23735.915    1545.7965    1545.7965 
    5000   -8405.4713   -8405.4713    -8492.918    -8492.918    338.42746    338.42746     23775.81     23775.81   -1484.0279   -1484.0279 
Loop time of 99.9227 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.433     | 99.433     | 99.433     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07511    | 0.07511    | 0.07511    |   0.0 |  0.08
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.35696    | 0.35696    | 0.35696    |   0.0 |  0.36
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116884.0 ave      116884 max      116884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116884
Ave neighs/atom = 58.442000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.271763731045, Press = -406.186639383158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8405.4713   -8405.4713    -8492.918    -8492.918    338.42746    338.42746     23775.81     23775.81   -1484.0279   -1484.0279 
    6000   -8403.0184   -8403.0184   -8490.2576   -8490.2576    337.62463    337.62463    23760.648    23760.648   -3.7148173   -3.7148173 
Loop time of 100.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.029 hours/ns, 9.910 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.4      | 100.4      | 100.4      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076299   | 0.076299   | 0.076299   |   0.0 |  0.08
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.37094    | 0.37094    | 0.37094    |   0.0 |  0.37
Other   |            | 0.05728    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116752.0 ave      116752 max      116752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116752
Ave neighs/atom = 58.376000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.794216061294, Press = 13.0057102591213
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8403.0184   -8403.0184   -8490.2576   -8490.2576    337.62463    337.62463    23760.648    23760.648   -3.7148173   -3.7148173 
    7000   -8404.0415   -8404.0415   -8490.7759   -8490.7759    335.67114    335.67114    23763.668    23763.668   -354.90252   -354.90252 
Loop time of 99.0506 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.074731   | 0.074731   | 0.074731   |   0.0 |  0.08
Output  | 0.0001954  | 0.0001954  | 0.0001954  |   0.0 |  0.00
Modify  | 0.36548    | 0.36548    | 0.36548    |   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:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116794.0 ave      116794 max      116794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116794
Ave neighs/atom = 58.397000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.874100227258, Press = -16.3591272315833
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8404.0415   -8404.0415   -8490.7759   -8490.7759    335.67114    335.67114    23763.668    23763.668   -354.90252   -354.90252 
    8000   -8401.1428   -8401.1428   -8488.6013   -8488.6013    338.47347    338.47347    23787.589    23787.589   -1671.7471   -1671.7471 
Loop time of 100.405 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.9       | 99.9       | 99.9       |   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.00023979 | 0.00023979 | 0.00023979 |   0.0 |  0.00
Modify  | 0.37137    | 0.37137    | 0.37137    |   0.0 |  0.37
Other   |            | 0.05759    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116828.0 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.883625912602, Press = 7.3998166570474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8401.1428   -8401.1428   -8488.6013   -8488.6013    338.47347    338.47347    23787.589    23787.589   -1671.7471   -1671.7471 
    9000   -8405.1185   -8405.1185   -8487.9676   -8487.9676    320.63474    320.63474    23733.829    23733.829    2104.7604    2104.7604 
Loop time of 100.167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.824 hours/ns, 9.983 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.666     | 99.666     | 99.666     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074894   | 0.074894   | 0.074894   |   0.0 |  0.07
Output  | 0.0003005  | 0.0003005  | 0.0003005  |   0.0 |  0.00
Modify  | 0.36874    | 0.36874    | 0.36874    |   0.0 |  0.37
Other   |            | 0.05728    |            |       |  0.06

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

Total # of neighbors = 116888
Ave neighs/atom = 58.444000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.864809708596, Press = 15.6011555279443
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8405.1185   -8405.1185   -8487.9676   -8487.9676    320.63474    320.63474    23733.829    23733.829    2104.7604    2104.7604 
   10000   -8402.8072   -8402.8072    -8488.778    -8488.778    332.71606    332.71606    23733.922    23733.922    2009.2303    2009.2303 
Loop time of 100.548 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.930 hours/ns, 9.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.04     | 100.04     | 100.04     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076169   | 0.076169   | 0.076169   |   0.0 |  0.08
Output  | 0.00015736 | 0.00015736 | 0.00015736 |   0.0 |  0.00
Modify  | 0.37171    | 0.37171    | 0.37171    |   0.0 |  0.37
Other   |            | 0.05732    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2974.00 ave        2974 max        2974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116946.0 ave      116946 max      116946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116946
Ave neighs/atom = 58.473000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.020731828832, Press = -14.2592635124779
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8402.8072   -8402.8072    -8488.778    -8488.778    332.71606    332.71606    23733.922    23733.922    2009.2303    2009.2303 
   11000   -8404.0108   -8404.0108   -8490.2925   -8490.2925    333.91908    333.91908    23802.371    23802.371   -3030.3272   -3030.3272 
Loop time of 101.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.092 hours/ns, 9.888 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.62     | 100.62     | 100.62     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076101   | 0.076101   | 0.076101   |   0.0 |  0.08
Output  | 0.00015268 | 0.00015268 | 0.00015268 |   0.0 |  0.00
Modify  | 0.37565    | 0.37565    | 0.37565    |   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:        2975.00 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116910.0 ave      116910 max      116910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116910
Ave neighs/atom = 58.455000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.110812094375, Press = -8.42949402791573
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8404.0108   -8404.0108   -8490.2925   -8490.2925    333.91908    333.91908    23802.371    23802.371   -3030.3272   -3030.3272 
   12000   -8408.5074   -8408.5074   -8492.4204   -8492.4204    324.75224    324.75224    23755.357    23755.357   -161.20346   -161.20346 
Loop time of 99.9725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.770 hours/ns, 10.003 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.476     | 99.476     | 99.476     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075131   | 0.075131   | 0.075131   |   0.0 |  0.08
Output  | 0.00015205 | 0.00015205 | 0.00015205 |   0.0 |  0.00
Modify  | 0.36499    | 0.36499    | 0.36499    |   0.0 |  0.37
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:        2966.00 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.803423165105, Press = 8.97283725078752
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8408.5074   -8408.5074   -8492.4204   -8492.4204    324.75224    324.75224    23755.357    23755.357   -161.20346   -161.20346 
   13000     -8404.12     -8404.12   -8488.5906   -8488.5906    326.90978    326.90978    23742.675    23742.675    1447.3373    1447.3373 
Loop time of 99.5931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.665 hours/ns, 10.041 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.093     | 99.093     | 99.093     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074964   | 0.074964   | 0.074964   |   0.0 |  0.08
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.36825    | 0.36825    | 0.36825    |   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:        2975.00 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116842.0 ave      116842 max      116842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116842
Ave neighs/atom = 58.421000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.653344367097, Press = -1.73179694413804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000     -8404.12     -8404.12   -8488.5906   -8488.5906    326.90978    326.90978    23742.675    23742.675    1447.3373    1447.3373 
   14000   -8401.9263   -8401.9263    -8490.711    -8490.711    343.60609    343.60609    23776.697    23776.697   -1201.1108   -1201.1108 
Loop time of 99.0711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.520 hours/ns, 10.094 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.577     | 98.577     | 98.577     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074147   | 0.074147   | 0.074147   |   0.0 |  0.07
Output  | 0.0001538  | 0.0001538  | 0.0001538  |   0.0 |  0.00
Modify  | 0.36312    | 0.36312    | 0.36312    |   0.0 |  0.37
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116930.0 ave      116930 max      116930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116930
Ave neighs/atom = 58.465000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.715115377332, Press = -3.97503028772999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8401.9263   -8401.9263    -8490.711    -8490.711    343.60609    343.60609    23776.697    23776.697   -1201.1108   -1201.1108 
   15000   -8406.4963   -8406.4963   -8493.2863   -8493.2863    335.88655    335.88655    23770.821    23770.821   -1139.3751   -1139.3751 
Loop time of 98.7337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.426 hours/ns, 10.128 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.242     | 98.242     | 98.242     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073875   | 0.073875   | 0.073875   |   0.0 |  0.07
Output  | 0.00037238 | 0.00037238 | 0.00037238 |   0.0 |  0.00
Modify  | 0.36102    | 0.36102    | 0.36102    |   0.0 |  0.37
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116808.0 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.566730511629, Press = 1.05202687591336
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8406.4963   -8406.4963   -8493.2863   -8493.2863    335.88655    335.88655    23770.821    23770.821   -1139.3751   -1139.3751 
   16000   -8400.6861   -8400.6861   -8488.9115   -8488.9115    341.44114    341.44114    23722.388    23722.388    3080.8314    3080.8314 
Loop time of 98.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.490 hours/ns, 10.105 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.47      | 98.47      | 98.47      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07382    | 0.07382    | 0.07382    |   0.0 |  0.07
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.36408    | 0.36408    | 0.36408    |   0.0 |  0.37
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.597738072717, Press = 5.07710526284324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8400.6861   -8400.6861   -8488.9115   -8488.9115    341.44114    341.44114    23722.388    23722.388    3080.8314    3080.8314 
   17000    -8402.071    -8402.071   -8488.2935   -8488.2935    333.69004    333.69004    23737.834    23737.834    1896.2221    1896.2221 
Loop time of 99.5355 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.649 hours/ns, 10.047 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.039     | 99.039     | 99.039     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074214   | 0.074214   | 0.074214   |   0.0 |  0.07
Output  | 0.00015037 | 0.00015037 | 0.00015037 |   0.0 |  0.00
Modify  | 0.36556    | 0.36556    | 0.36556    |   0.0 |  0.37
Other   |            | 0.05697    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116998.0 ave      116998 max      116998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116998
Ave neighs/atom = 58.499000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.6840974641, Press = -8.65715974662355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -8402.071    -8402.071   -8488.2935   -8488.2935    333.69004    333.69004    23737.834    23737.834    1896.2221    1896.2221 
   18000   -8404.6874   -8404.6874   -8491.4062   -8491.4062    335.61084    335.61084    23793.627    23793.627   -2640.8894   -2640.8894 
Loop time of 99.2495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.569 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.752     | 98.752     | 98.752     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074717   | 0.074717   | 0.074717   |   0.0 |  0.08
Output  | 0.00018976 | 0.00018976 | 0.00018976 |   0.0 |  0.00
Modify  | 0.36556    | 0.36556    | 0.36556    |   0.0 |  0.37
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116914.0 ave      116914 max      116914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116914
Ave neighs/atom = 58.457000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.903053916427, Press = -2.31194996198508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8404.6874   -8404.6874   -8491.4062   -8491.4062    335.61084    335.61084    23793.627    23793.627   -2640.8894   -2640.8894 
   19000    -8399.128    -8399.128   -8486.7688   -8486.7688    339.17886    339.17886    23765.072    23765.072    244.79284    244.79284 
Loop time of 99.812 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.726 hours/ns, 10.019 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.315     | 99.315     | 99.315     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074554   | 0.074554   | 0.074554   |   0.0 |  0.07
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.36575    | 0.36575    | 0.36575    |   0.0 |  0.37
Other   |            | 0.057      |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116802.0 ave      116802 max      116802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116802
Ave neighs/atom = 58.401000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.064135271085, Press = 4.01980669234838
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -8399.128    -8399.128   -8486.7688   -8486.7688    339.17886    339.17886    23765.072    23765.072    244.79284    244.79284 
   20000   -8403.7106   -8403.7106   -8491.3093   -8491.3093     339.0159     339.0159    23734.223    23734.223    1557.3505    1557.3505 
Loop time of 99.2654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.574 hours/ns, 10.074 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.765     | 98.765     | 98.765     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074979   | 0.074979   | 0.074979   |   0.0 |  0.08
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.36719    | 0.36719    | 0.36719    |   0.0 |  0.37
Other   |            | 0.05766    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116876.0 ave      116876 max      116876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116876
Ave neighs/atom = 58.438000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.197412903871, Press = -1.10543234203039
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8403.7106   -8403.7106   -8491.3093   -8491.3093     339.0159     339.0159    23734.223    23734.223    1557.3505    1557.3505 
   21000   -8404.8239   -8404.8239   -8489.5787   -8489.5787    328.00977    328.00977    23772.575    23772.575   -758.15077   -758.15077 
Loop time of 98.6869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.413 hours/ns, 10.133 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.191     | 98.191     | 98.191     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074374   | 0.074374   | 0.074374   |   0.0 |  0.08
Output  | 0.00020301 | 0.00020301 | 0.00020301 |   0.0 |  0.00
Modify  | 0.36405    | 0.36405    | 0.36405    |   0.0 |  0.37
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116956.0 ave      116956 max      116956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116956
Ave neighs/atom = 58.478000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152347724162, Press = -2.54779663529977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8404.8239   -8404.8239   -8489.5787   -8489.5787    328.00977    328.00977    23772.575    23772.575   -758.15077   -758.15077 
   22000   -8402.5985   -8402.5985    -8490.365    -8490.365     339.6655     339.6655    23778.576    23778.576   -1174.0083   -1174.0083 
Loop time of 98.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.332 hours/ns, 10.163 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.899     | 97.899     | 97.899     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074525   | 0.074525   | 0.074525   |   0.0 |  0.08
Output  | 0.00015478 | 0.00015478 | 0.00015478 |   0.0 |  0.00
Modify  | 0.36364    | 0.36364    | 0.36364    |   0.0 |  0.37
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116888.0 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.077101526651, Press = 2.12136783213957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8402.5985   -8402.5985    -8490.365    -8490.365     339.6655     339.6655    23778.576    23778.576   -1174.0083   -1174.0083 
   23000   -8407.1233   -8407.1233   -8492.7553   -8492.7553    331.40451    331.40451    23720.392    23720.392    2353.9575    2353.9575 
Loop time of 99.5365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.649 hours/ns, 10.047 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.039     | 99.039     | 99.039     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074368   | 0.074368   | 0.074368   |   0.0 |  0.07
Output  | 0.00020046 | 0.00020046 | 0.00020046 |   0.0 |  0.00
Modify  | 0.36633    | 0.36633    | 0.36633    |   0.0 |  0.37
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116784.0 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.957831789569, Press = 0.662581676571458
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8407.1233   -8407.1233   -8492.7553   -8492.7553    331.40451    331.40451    23720.392    23720.392    2353.9575    2353.9575 
   24000   -8402.8037   -8402.8037   -8488.2051   -8488.2051    330.51247    330.51247    23769.997    23769.997   -384.98693   -384.98693 
Loop time of 99.8628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.740 hours/ns, 10.014 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.358     | 99.358     | 99.358     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074729   | 0.074729   | 0.074729   |   0.0 |  0.07
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.37148    | 0.37148    | 0.37148    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116848.0 ave      116848 max      116848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116848
Ave neighs/atom = 58.424000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920570183962, Press = -5.01284837751977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8402.8037   -8402.8037   -8488.2051   -8488.2051    330.51247    330.51247    23769.997    23769.997   -384.98693   -384.98693 
   25000   -8402.9566   -8402.9566   -8488.4693   -8488.4693     330.9427     330.9427    23798.359    23798.359   -2320.2681   -2320.2681 
Loop time of 99.4655 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.97      | 98.97      | 98.97      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074464   | 0.074464   | 0.074464   |   0.0 |  0.07
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.36366    | 0.36366    | 0.36366    |   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:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116810.0 ave      116810 max      116810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116810
Ave neighs/atom = 58.405000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.928277692681, Press = 1.36085847920058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8402.9566   -8402.9566   -8488.4693   -8488.4693     330.9427     330.9427    23798.359    23798.359   -2320.2681   -2320.2681 
   26000   -8405.5239   -8405.5239   -8492.0391   -8492.0391    334.82269    334.82269     23736.42     23736.42    1359.9136    1359.9136 
Loop time of 99.8357 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.732 hours/ns, 10.016 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.335     | 99.335     | 99.335     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074754   | 0.074754   | 0.074754   |   0.0 |  0.07
Output  | 0.00015584 | 0.00015584 | 0.00015584 |   0.0 |  0.00
Modify  | 0.36879    | 0.36879    | 0.36879    |   0.0 |  0.37
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.090651253327, Press = 1.77496255763714
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8405.5239   -8405.5239   -8492.0391   -8492.0391    334.82269    334.82269     23736.42     23736.42    1359.9136    1359.9136 
   27000    -8403.581    -8403.581   -8489.3666   -8489.3666    331.99922    331.99922    23745.134    23745.134    1165.8092    1165.8092 
Loop time of 100.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.800 hours/ns, 9.992 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.578     | 99.578     | 99.578     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07559    | 0.07559    | 0.07559    |   0.0 |  0.08
Output  | 0.0001912  | 0.0001912  | 0.0001912  |   0.0 |  0.00
Modify  | 0.36986    | 0.36986    | 0.36986    |   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:        2966.00 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116856.0 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152259304331, Press = -1.64651104320825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000    -8403.581    -8403.581   -8489.3666   -8489.3666    331.99922    331.99922    23745.134    23745.134    1165.8092    1165.8092 
   28000   -8406.1283   -8406.1283   -8489.6756   -8489.6756    323.33665    323.33665    23758.977    23758.977   -2.8318935   -2.8318935 
Loop time of 98.8713 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.375     | 98.375     | 98.375     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074292   | 0.074292   | 0.074292   |   0.0 |  0.08
Output  | 0.0001532  | 0.0001532  | 0.0001532  |   0.0 |  0.00
Modify  | 0.36477    | 0.36477    | 0.36477    |   0.0 |  0.37
Other   |            | 0.05726    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2966.00 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116950.0 ave      116950 max      116950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116950
Ave neighs/atom = 58.475000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.20671501114, Press = -0.693019874578679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8406.1283   -8406.1283   -8489.6756   -8489.6756    323.33665    323.33665    23758.977    23758.977   -2.8318935   -2.8318935 
   29000   -8400.4649   -8400.4649   -8487.1265   -8487.1265    335.38928    335.38928    23761.555    23761.555    541.60623    541.60623 
Loop time of 97.2089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.889 ns/day, 27.002 hours/ns, 10.287 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.723     | 96.723     | 96.723     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073319   | 0.073319   | 0.073319   |   0.0 |  0.08
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.35592    | 0.35592    | 0.35592    |   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:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116916.0 ave      116916 max      116916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116916
Ave neighs/atom = 58.458000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.218002480355, Press = -0.621055059093185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8400.4649   -8400.4649   -8487.1265   -8487.1265    335.38928    335.38928    23761.555    23761.555    541.60623    541.60623 
   30000   -8404.5072   -8404.5072   -8491.5316   -8491.5316    336.79348    336.79348    23769.412    23769.412   -903.95419   -903.95419 
Loop time of 100.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.790 hours/ns, 9.996 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.544     | 99.544     | 99.544     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074801   | 0.074801   | 0.074801   |   0.0 |  0.07
Output  | 0.00015947 | 0.00015947 | 0.00015947 |   0.0 |  0.00
Modify  | 0.36716    | 0.36716    | 0.36716    |   0.0 |  0.37
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116808.0 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.323170942594, Press = -1.02656581401725
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8404.5072   -8404.5072   -8491.5316   -8491.5316    336.79348    336.79348    23769.412    23769.412   -903.95419   -903.95419 
   31000   -8399.8158   -8399.8158   -8485.7363   -8485.7363    332.52136    332.52136        23794        23794     -1556.36     -1556.36 
Loop time of 99.6107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.670 hours/ns, 10.039 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.112     | 99.112     | 99.112     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07504    | 0.07504    | 0.07504    |   0.0 |  0.08
Output  | 0.00020434 | 0.00020434 | 0.00020434 |   0.0 |  0.00
Modify  | 0.36608    | 0.36608    | 0.36608    |   0.0 |  0.37
Other   |            | 0.05733    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116852.0 ave      116852 max      116852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116852
Ave neighs/atom = 58.426000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.368114850843, Press = 1.06973527630848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8399.8158   -8399.8158   -8485.7363   -8485.7363    332.52136    332.52136        23794        23794     -1556.36     -1556.36 
   32000   -8404.0534   -8404.0534   -8491.8045   -8491.8045    339.60586    339.60586    23725.948    23725.948     2194.043     2194.043 
Loop time of 98.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.386     | 98.386     | 98.386     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074882   | 0.074882   | 0.074882   |   0.0 |  0.08
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.36618    | 0.36618    | 0.36618    |   0.0 |  0.37
Other   |            | 0.05714    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2970.00 ave        2970 max        2970 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.312819128286, Press = 1.76566807829897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8404.0534   -8404.0534   -8491.8045   -8491.8045    339.60586    339.60586    23725.948    23725.948     2194.043     2194.043 
   33000   -8402.8575   -8402.8575   -8488.7948   -8488.7948    332.58627    332.58627      23738.7      23738.7    1757.0391    1757.0391 
Loop time of 99.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.02      | 99.02      | 99.02      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074816   | 0.074816   | 0.074816   |   0.0 |  0.08
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.36544    | 0.36544    | 0.36544    |   0.0 |  0.37
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2977.00 ave        2977 max        2977 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116892.0 ave      116892 max      116892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116892
Ave neighs/atom = 58.446000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.247961610695, Press = -2.43222421705099
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8402.8575   -8402.8575   -8488.7948   -8488.7948    332.58627    332.58627      23738.7      23738.7    1757.0391    1757.0391 
   34000   -8404.1981   -8404.1981   -8489.7843   -8489.7843    331.22743    331.22743    23781.148    23781.148   -1414.1586   -1414.1586 
Loop time of 99.3577 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.855     | 98.855     | 98.855     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075584   | 0.075584   | 0.075584   |   0.0 |  0.08
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.3692     | 0.3692     | 0.3692     |   0.0 |  0.37
Other   |            | 0.0574     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2973.00 ave        2973 max        2973 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116952.0 ave      116952 max      116952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116952
Ave neighs/atom = 58.476000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.145939025914, Press = -1.74103572622085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8404.1981   -8404.1981   -8489.7843   -8489.7843    331.22743    331.22743    23781.148    23781.148   -1414.1586   -1414.1586 
   35000   -8406.1654   -8406.1654   -8491.4541   -8491.4541    330.07603    330.07603    23769.715    23769.715   -967.72694   -967.72694 
Loop time of 98.3154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.310 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.07425    | 0.07425    | 0.07425    |   0.0 |  0.08
Output  | 0.0001886  | 0.0001886  | 0.0001886  |   0.0 |  0.00
Modify  | 0.3606     | 0.3606     | 0.3606     |   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:        2966.00 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116800.0 ave      116800 max      116800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116800
Ave neighs/atom = 58.400000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.107364259283, Press = 0.72779226937211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8406.1654   -8406.1654   -8491.4541   -8491.4541    330.07603    330.07603    23769.715    23769.715   -967.72694   -967.72694 
   36000   -8401.3413   -8401.3413   -8488.8992   -8488.8992     338.8579     338.8579    23736.285    23736.285    2036.1749    2036.1749 
Loop time of 99.1831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.551 hours/ns, 10.082 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.684     | 98.684     | 98.684     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07423    | 0.07423    | 0.07423    |   0.0 |  0.07
Output  | 0.00015704 | 0.00015704 | 0.00015704 |   0.0 |  0.00
Modify  | 0.36691    | 0.36691    | 0.36691    |   0.0 |  0.37
Other   |            | 0.05745    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116860.0 ave      116860 max      116860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116860
Ave neighs/atom = 58.430000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.173368109058, Press = -0.445104975263616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8401.3413   -8401.3413   -8488.8992   -8488.8992     338.8579     338.8579    23736.285    23736.285    2036.1749    2036.1749 
   37000   -8405.0409   -8405.0409     -8488.36     -8488.36    322.45359    322.45359    23771.219    23771.219   -604.60701   -604.60701 
Loop time of 99.365 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.865     | 98.865     | 98.865     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075023   | 0.075023   | 0.075023   |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.36793    | 0.36793    | 0.36793    |   0.0 |  0.37
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116898.0 ave      116898 max      116898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116898
Ave neighs/atom = 58.449000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.233348561595, Press = -2.72012012682172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8405.0409   -8405.0409     -8488.36     -8488.36    322.45359    322.45359    23771.219    23771.219   -604.60701   -604.60701 
   38000    -8399.951    -8399.951   -8485.9897   -8485.9897    332.97846    332.97846    23818.753    23818.753   -3484.1477   -3484.1477 
Loop time of 101.273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.131 hours/ns, 9.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.76     | 100.76     | 100.76     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075999   | 0.075999   | 0.075999   |   0.0 |  0.08
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.37609    | 0.37609    | 0.37609    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116944.0 ave      116944 max      116944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116944
Ave neighs/atom = 58.472000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.323808539669, Press = 1.72499954803179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -8399.951    -8399.951   -8485.9897   -8485.9897    332.97846    332.97846    23818.753    23818.753   -3484.1477   -3484.1477 
   39000   -8402.4727   -8402.4727   -8488.7587   -8488.7587    333.93563    333.93563    23733.753    23733.753    2098.5687    2098.5687 
Loop time of 100.189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.830 hours/ns, 9.981 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.687     | 99.687     | 99.687     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074794   | 0.074794   | 0.074794   |   0.0 |  0.07
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.36978    | 0.36978    | 0.36978    |   0.0 |  0.37
Other   |            | 0.05739    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116846.0 ave      116846 max      116846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116846
Ave neighs/atom = 58.423000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.340256655704, Press = 1.2131046548307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8402.4727   -8402.4727   -8488.7587   -8488.7587    333.93563    333.93563    23733.753    23733.753    2098.5687    2098.5687 
   40000   -8409.2227   -8409.2227   -8492.9581   -8492.9581    324.06458    324.06458    23736.009    23736.009    1290.8991    1290.8991 
Loop time of 100.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.888 hours/ns, 9.961 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.89      | 99.89      | 99.89      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074722   | 0.074722   | 0.074722   |   0.0 |  0.07
Output  | 0.00021774 | 0.00021774 | 0.00021774 |   0.0 |  0.00
Modify  | 0.37324    | 0.37324    | 0.37324    |   0.0 |  0.37
Other   |            | 0.05768    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116942.0 ave      116942 max      116942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116942
Ave neighs/atom = 58.471000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.295569448958, Press = -1.88628752984218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8409.2227   -8409.2227   -8492.9581   -8492.9581    324.06458    324.06458    23736.009    23736.009    1290.8991    1290.8991 
   41000   -8402.7755   -8402.7755   -8489.9816   -8489.9816    337.49642    337.49642    23793.895    23793.895   -2300.5151   -2300.5151 
Loop time of 98.4276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.341 hours/ns, 10.160 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.934     | 97.934     | 97.934     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074571   | 0.074571   | 0.074571   |   0.0 |  0.08
Output  | 0.00045918 | 0.00045918 | 0.00045918 |   0.0 |  0.00
Modify  | 0.36207    | 0.36207    | 0.36207    |   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:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116838.0 ave      116838 max      116838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116838
Ave neighs/atom = 58.419000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.236011755524, Press = -0.526641261879355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8402.7755   -8402.7755   -8489.9816   -8489.9816    337.49642    337.49642    23793.895    23793.895   -2300.5151   -2300.5151 
   42000   -8404.3402   -8404.3402   -8490.4421   -8490.4421    333.22356    333.22356    23759.027    23759.027   -31.951628   -31.951628 
Loop time of 100.351 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.843     | 99.843     | 99.843     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07543    | 0.07543    | 0.07543    |   0.0 |  0.08
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.37416    | 0.37416    | 0.37416    |   0.0 |  0.37
Other   |            | 0.05805    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116856.0 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.238962722794, Press = 1.07531666059152
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8404.3402   -8404.3402   -8490.4421   -8490.4421    333.22356    333.22356    23759.027    23759.027   -31.951628   -31.951628 
   43000   -8404.4806   -8404.4806   -8490.2216   -8490.2216    331.82656    331.82656    23707.816    23707.816    3759.2389    3759.2389 
Loop time of 98.8766 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.38      | 98.38      | 98.38      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074328   | 0.074328   | 0.074328   |   0.0 |  0.08
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.36533    | 0.36533    | 0.36533    |   0.0 |  0.37
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116866.0 ave      116866 max      116866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116866
Ave neighs/atom = 58.433000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.184954546524, Press = -0.918362056293156
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8404.4806   -8404.4806   -8490.2216   -8490.2216    331.82656    331.82656    23707.816    23707.816    3759.2389    3759.2389 
   44000   -8404.0833   -8404.0833   -8491.0819   -8491.0819    336.69353    336.69353    23799.182    23799.182   -2660.7895   -2660.7895 
Loop time of 99.5785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.661 hours/ns, 10.042 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.081     | 99.081     | 99.081     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074639   | 0.074639   | 0.074639   |   0.0 |  0.07
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.36564    | 0.36564    | 0.36564    |   0.0 |  0.37
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116918.0 ave      116918 max      116918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116918
Ave neighs/atom = 58.459000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.223900044087, Press = -3.60457184271936
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8404.0833   -8404.0833   -8491.0819   -8491.0819    336.69353    336.69353    23799.182    23799.182   -2660.7895   -2660.7895 
   45000   -8401.1496   -8401.1496   -8487.8361   -8487.8361    335.48545    335.48545    23784.117    23784.117   -1182.8152   -1182.8152 
Loop time of 99.0206 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.506 hours/ns, 10.099 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.524     | 98.524     | 98.524     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074285   | 0.074285   | 0.074285   |   0.0 |  0.08
Output  | 0.00014866 | 0.00014866 | 0.00014866 |   0.0 |  0.00
Modify  | 0.36519    | 0.36519    | 0.36519    |   0.0 |  0.37
Other   |            | 0.05699    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116750.0 ave      116750 max      116750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116750
Ave neighs/atom = 58.375000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.214408679394, Press = 0.653945235045892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8401.1496   -8401.1496   -8487.8361   -8487.8361    335.48545    335.48545    23784.117    23784.117   -1182.8152   -1182.8152 
   46000   -8404.9828   -8404.9828   -8489.5779   -8489.5779    327.39153    327.39153    23740.194    23740.194    1547.0408    1547.0408 
Loop time of 98.0097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.225 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.518     | 97.518     | 97.518     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074431   | 0.074431   | 0.074431   |   0.0 |  0.08
Output  | 0.00019171 | 0.00019171 | 0.00019171 |   0.0 |  0.00
Modify  | 0.36       | 0.36       | 0.36       |   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:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116844.0 ave      116844 max      116844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116844
Ave neighs/atom = 58.422000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.281497981771, Press = 0.342558046518955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8404.9828   -8404.9828   -8489.5779   -8489.5779    327.39153    327.39153    23740.194    23740.194    1547.0408    1547.0408 
   47000   -8400.9206   -8400.9206   -8490.6119   -8490.6119     347.1144     347.1144    23765.082    23765.082   -371.24991   -371.24991 
Loop time of 100.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.928 hours/ns, 9.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.03     | 100.03     | 100.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075911   | 0.075911   | 0.075911   |   0.0 |  0.08
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.37606    | 0.37606    | 0.37606    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116902.0 ave      116902 max      116902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116902
Ave neighs/atom = 58.451000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.301329951197, Press = -1.57744195484754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8400.9206   -8400.9206   -8490.6119   -8490.6119     347.1144     347.1144    23765.082    23765.082   -371.24991   -371.24991 
   48000   -8406.9613   -8406.9613   -8492.5113   -8492.5113    331.08755    331.08755    23799.735    23799.735   -3252.2566   -3252.2566 
Loop time of 99.1523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.542 hours/ns, 10.085 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.655     | 98.655     | 98.655     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075113   | 0.075113   | 0.075113   |   0.0 |  0.08
Output  | 0.00015231 | 0.00015231 | 0.00015231 |   0.0 |  0.00
Modify  | 0.36496    | 0.36496    | 0.36496    |   0.0 |  0.37
Other   |            | 0.05723    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116818.0 ave      116818 max      116818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0