# 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 3.302443556487561*${_u_distance}
variable latticeconst_converted equal 3.302443556487561*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30244355648756
Lattice spacing in x,y,z = 3.3024436 3.3024436 3.3024436
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 (33.024436 33.024436 33.024436)
  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 (33.024436 33.024436 33.024436)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimJungLee_2010_FeNbC__MO_072689718616_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 36016.8901176252    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*1*${_u_distance})
variable      V0_metal equal 36016.8901176252/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 36016.8901176252*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36016.8901176252 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_072689718616_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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.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   -14864.253   -14864.253       -14940       -14940       293.15       293.15     36016.89     36016.89    2246.3865    2246.3865 
    1000    -14786.82    -14786.82   -14866.989   -14866.989    310.26302    310.26302    36149.345    36149.345    2115.7922    2115.7922 
Loop time of 117.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.733 ns/day, 32.746 hours/ns, 8.483 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    | 117.39     | 117.39     | 117.39     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076498   | 0.076498   | 0.076498   |   0.0 |  0.06
Output  | 0.00019624 | 0.00019624 | 0.00019624 |   0.0 |  0.00
Modify  | 0.35782    | 0.35782    | 0.35782    |   0.0 |  0.30
Other   |            | 0.05717    |            |       |  0.05

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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -14786.82    -14786.82   -14866.989   -14866.989    310.26302    310.26302    36149.345    36149.345    2115.7922    2115.7922 
    2000    -14785.22    -14785.22   -14857.771   -14857.771    280.78098    280.78098    36178.432    36178.432     1226.287     1226.287 
Loop time of 131.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.498 hours/ns, 7.611 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    | 130.88     | 130.88     | 130.88     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087      | 0.087      | 0.087      |   0.0 |  0.07
Output  | 0.00023354 | 0.00023354 | 0.00023354 |   0.0 |  0.00
Modify  | 0.3674     | 0.3674     | 0.3674     |   0.0 |  0.28
Other   |            | 0.05988    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3386.00 ave        3386 max        3386 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:      121158.0 ave      121158 max      121158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121158
Ave neighs/atom = 60.579000
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -14785.22    -14785.22   -14857.771   -14857.771    280.78098    280.78098    36178.432    36178.432     1226.287     1226.287 
    3000   -14788.805   -14788.805   -14862.701   -14862.701    285.98608    285.98608    36172.115    36172.115    990.03379    990.03379 
Loop time of 131.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.462 hours/ns, 7.618 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    | 130.75     | 130.75     | 130.75     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085536   | 0.085536   | 0.085536   |   0.0 |  0.07
Output  | 0.00019247 | 0.00019247 | 0.00019247 |   0.0 |  0.00
Modify  | 0.36906    | 0.36906    | 0.36906    |   0.0 |  0.28
Other   |            | 0.05949    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3341.00 ave        3341 max        3341 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:      121066.0 ave      121066 max      121066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121066
Ave neighs/atom = 60.533000
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -14788.805   -14788.805   -14862.701   -14862.701    285.98608    285.98608    36172.115    36172.115    990.03379    990.03379 
    4000   -14784.604   -14784.604   -14860.666   -14860.666    294.36934    294.36934    36189.063    36189.063    487.05987    487.05987 
Loop time of 129.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.015 hours/ns, 7.713 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    | 129.15     | 129.15     | 129.15     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085128   | 0.085128   | 0.085128   |   0.0 |  0.07
Output  | 0.00024059 | 0.00024059 | 0.00024059 |   0.0 |  0.00
Modify  | 0.3637     | 0.3637     | 0.3637     |   0.0 |  0.28
Other   |            | 0.05967    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3361.00 ave        3361 max        3361 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:      121062.0 ave      121062 max      121062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121062
Ave neighs/atom = 60.531000
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -14784.604   -14784.604   -14860.666   -14860.666    294.36934    294.36934    36189.063    36189.063    487.05987    487.05987 
    5000   -14788.516   -14788.516    -14863.01    -14863.01    288.29986    288.29986    36189.248    36189.248    205.25609    205.25609 
Loop time of 129.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.025 hours/ns, 7.711 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    | 129.18     | 129.18     | 129.18     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085587   | 0.085587   | 0.085587   |   0.0 |  0.07
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.36349    | 0.36349    | 0.36349    |   0.0 |  0.28
Other   |            | 0.05917    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3376.00 ave        3376 max        3376 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:      121032.0 ave      121032 max      121032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121032
Ave neighs/atom = 60.516000
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 = 292.1605547624, Press = 310.821858258357
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -14788.516   -14788.516    -14863.01    -14863.01    288.29986    288.29986    36189.248    36189.248    205.25609    205.25609 
    6000   -14784.617   -14784.617   -14860.965   -14860.965    295.47512    295.47512    36207.133    36207.133    -661.5833    -661.5833 
Loop time of 130.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.160 hours/ns, 7.682 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.65     | 129.65     | 129.65     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086135   | 0.086135   | 0.086135   |   0.0 |  0.07
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.38204    | 0.38204    | 0.38204    |   0.0 |  0.29
Other   |            | 0.05976    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3390.00 ave        3390 max        3390 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:      121084.0 ave      121084 max      121084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121084
Ave neighs/atom = 60.542000
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 = 293.00339196736, Press = 54.9971668059297
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -14784.617   -14784.617   -14860.965   -14860.965    295.47512    295.47512    36207.133    36207.133    -661.5833    -661.5833 
    7000   -14787.138   -14787.138   -14863.689   -14863.689    296.26167    296.26167    36223.505    36223.505   -1606.1187   -1606.1187 
Loop time of 128.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.758 hours/ns, 7.768 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    | 128.2      | 128.2      | 128.2      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087126   | 0.087126   | 0.087126   |   0.0 |  0.07
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.3782     | 0.3782     | 0.3782     |   0.0 |  0.29
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3410.00 ave        3410 max        3410 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:      121026.0 ave      121026 max      121026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121026
Ave neighs/atom = 60.513000
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 = 291.994673349973, Press = 22.2750751026823
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -14787.138   -14787.138   -14863.689   -14863.689    296.26167    296.26167    36223.505    36223.505   -1606.1187   -1606.1187 
    8000   -14785.341   -14785.341   -14864.353   -14864.353     305.7845     305.7845    36225.497    36225.497    -1771.948    -1771.948 
Loop time of 130.167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.157 hours/ns, 7.682 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    | 129.64     | 129.64     | 129.64     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086783   | 0.086783   | 0.086783   |   0.0 |  0.07
Output  | 0.00018659 | 0.00018659 | 0.00018659 |   0.0 |  0.00
Modify  | 0.38228    | 0.38228    | 0.38228    |   0.0 |  0.29
Other   |            | 0.05976    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3393.00 ave        3393 max        3393 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:      120844.0 ave      120844 max      120844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120844
Ave neighs/atom = 60.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 = 292.061952089102, Press = 4.29797626793522
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -14785.341   -14785.341   -14864.353   -14864.353     305.7845     305.7845    36225.497    36225.497    -1771.948    -1771.948 
    9000   -14783.063   -14783.063   -14858.098   -14858.098    290.39516    290.39516    36209.426    36209.426   -527.39883   -527.39883 
Loop time of 127.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.676 ns/day, 35.526 hours/ns, 7.819 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    | 127.38     | 127.38     | 127.38     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084554   | 0.084554   | 0.084554   |   0.0 |  0.07
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.37241    | 0.37241    | 0.37241    |   0.0 |  0.29
Other   |            | 0.05871    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3337.00 ave        3337 max        3337 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:      120884.0 ave      120884 max      120884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120884
Ave neighs/atom = 60.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 = 292.230690830613, Press = 1.73330835704291
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -14783.063   -14783.063   -14858.098   -14858.098    290.39516    290.39516    36209.426    36209.426   -527.39883   -527.39883 
   10000   -14787.205   -14787.205    -14861.78    -14861.78    288.61474    288.61474    36218.695    36218.695   -1309.0212   -1309.0212 
Loop time of 131.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.532 hours/ns, 7.604 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    | 130.98     | 130.98     | 130.98     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086119   | 0.086119   | 0.086119   |   0.0 |  0.07
Output  | 0.00015368 | 0.00015368 | 0.00015368 |   0.0 |  0.00
Modify  | 0.38921    | 0.38921    | 0.38921    |   0.0 |  0.30
Other   |            | 0.05998    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3319.00 ave        3319 max        3319 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:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.943894288576, Press = 1.09830302353338
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -14787.205   -14787.205    -14861.78    -14861.78    288.61474    288.61474    36218.695    36218.695   -1309.0212   -1309.0212 
   11000   -14784.888   -14784.888   -14861.707   -14861.707    297.29943    297.29943     36220.76     36220.76   -1335.9951   -1335.9951 
Loop time of 128.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.663 hours/ns, 7.789 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    | 127.87     | 127.87     | 127.87     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082555   | 0.082555   | 0.082555   |   0.0 |  0.06
Output  | 0.00015002 | 0.00015002 | 0.00015002 |   0.0 |  0.00
Modify  | 0.37071    | 0.37071    | 0.37071    |   0.0 |  0.29
Other   |            | 0.05866    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3301.00 ave        3301 max        3301 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:      120912.0 ave      120912 max      120912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120912
Ave neighs/atom = 60.456000
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 = 293.034400780199, Press = -0.739015857864026
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -14784.888   -14784.888   -14861.707   -14861.707    297.29943    297.29943     36220.76     36220.76   -1335.9951   -1335.9951 
   12000   -14788.123   -14788.123   -14862.345   -14862.345    287.24684    287.24684    36225.271    36225.271   -1630.2267   -1630.2267 
Loop time of 127.327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.369 hours/ns, 7.854 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    | 126.81     | 126.81     | 126.81     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083586   | 0.083586   | 0.083586   |   0.0 |  0.07
Output  | 0.00018832 | 0.00018832 | 0.00018832 |   0.0 |  0.00
Modify  | 0.37179    | 0.37179    | 0.37179    |   0.0 |  0.29
Other   |            | 0.05856    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 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:      120914.0 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.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 = 293.096947475121, Press = -2.18330748019013
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -14788.123   -14788.123   -14862.345   -14862.345    287.24684    287.24684    36225.271    36225.271   -1630.2267   -1630.2267 
   13000   -14784.784   -14784.784   -14861.683   -14861.683    297.60576    297.60576    36226.453    36226.453   -1640.6243   -1640.6243 
Loop time of 129.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.924 hours/ns, 7.732 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    | 128.8      | 128.8      | 128.8      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08569    | 0.08569    | 0.08569    |   0.0 |  0.07
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.37742    | 0.37742    | 0.37742    |   0.0 |  0.29
Other   |            | 0.05956    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3365.00 ave        3365 max        3365 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:      120932.0 ave      120932 max      120932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120932
Ave neighs/atom = 60.466000
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 = 293.478831816501, Press = -5.43547985986576
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -14784.784   -14784.784   -14861.683   -14861.683    297.60576    297.60576    36226.453    36226.453   -1640.6243   -1640.6243 
   14000   -14787.092   -14787.092   -14863.143   -14863.143    294.32339    294.32339     36203.01     36203.01   -524.92504   -524.92504 
Loop time of 127.274 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.354 hours/ns, 7.857 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    | 126.76     | 126.76     | 126.76     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084908   | 0.084908   | 0.084908   |   0.0 |  0.07
Output  | 0.00018891 | 0.00018891 | 0.00018891 |   0.0 |  0.00
Modify  | 0.37325    | 0.37325    | 0.37325    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3397.00 ave        3397 max        3397 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:      120968.0 ave      120968 max      120968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120968
Ave neighs/atom = 60.484000
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 = 293.477703184476, Press = -6.18130125841626
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -14787.092   -14787.092   -14863.143   -14863.143    294.32339    294.32339     36203.01     36203.01   -524.92504   -524.92504 
   15000   -14783.914   -14783.914   -14861.604   -14861.604    300.66849    300.66849     36183.14     36183.14    662.48875    662.48875 
Loop time of 128.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.753 hours/ns, 7.769 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.19     | 128.19     | 128.19     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084411   | 0.084411   | 0.084411   |   0.0 |  0.07
Output  | 0.00045998 | 0.00045998 | 0.00045998 |   0.0 |  0.00
Modify  | 0.37486    | 0.37486    | 0.37486    |   0.0 |  0.29
Other   |            | 0.05938    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3368.00 ave        3368 max        3368 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:      120970.0 ave      120970 max      120970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120970
Ave neighs/atom = 60.485000
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 = 293.73274470717, Press = -3.42417802972879
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -14783.914   -14783.914   -14861.604   -14861.604    300.66849    300.66849     36183.14     36183.14    662.48875    662.48875 
   16000   -14787.468   -14787.468   -14862.896   -14862.896     291.9148     291.9148    36183.433    36183.433    607.43334    607.43334 
Loop time of 127.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.279 hours/ns, 7.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    | 126.49     | 126.49     | 126.49     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08347    | 0.08347    | 0.08347    |   0.0 |  0.07
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.37024    | 0.37024    | 0.37024    |   0.0 |  0.29
Other   |            | 0.05881    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3353.00 ave        3353 max        3353 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:      121124.0 ave      121124 max      121124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121124
Ave neighs/atom = 60.562000
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 = 293.893754390227, Press = 0.273260261870166
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -14787.468   -14787.468   -14862.896   -14862.896     291.9148     291.9148    36183.433    36183.433    607.43334    607.43334 
   17000   -14782.728   -14782.728   -14860.377   -14860.377    300.51222    300.51222    36199.146    36199.146   -13.219992   -13.219992 
Loop time of 127.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.438 hours/ns, 7.838 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.06     | 127.06     | 127.06     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083008   | 0.083008   | 0.083008   |   0.0 |  0.07
Output  | 0.00015435 | 0.00015435 | 0.00015435 |   0.0 |  0.00
Modify  | 0.37321    | 0.37321    | 0.37321    |   0.0 |  0.29
Other   |            | 0.05907    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3296.00 ave        3296 max        3296 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:      121106.0 ave      121106 max      121106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121106
Ave neighs/atom = 60.553000
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 = 293.918817214529, Press = 0.732239091013416
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -14782.728   -14782.728   -14860.377   -14860.377    300.51222    300.51222    36199.146    36199.146   -13.219992   -13.219992 
   18000   -14788.272   -14788.272    -14865.19    -14865.19     297.6808     297.6808     36189.31     36189.31    16.392178    16.392178 
Loop time of 128.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.709 hours/ns, 7.779 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    | 128.03     | 128.03     | 128.03     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084138   | 0.084138   | 0.084138   |   0.0 |  0.07
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.37423    | 0.37423    | 0.37423    |   0.0 |  0.29
Other   |            | 0.05903    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3342.00 ave        3342 max        3342 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:      121002.0 ave      121002 max      121002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121002
Ave neighs/atom = 60.501000
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 = 294.051364893152, Press = 0.847760552804418
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -14788.272   -14788.272    -14865.19    -14865.19     297.6808     297.6808     36189.31     36189.31    16.392178    16.392178 
   19000   -14786.589   -14786.589    -14864.22    -14864.22    300.43964    300.43964    36216.126    36216.126   -1245.1832   -1245.1832 
Loop time of 128.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.715 hours/ns, 7.778 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    | 128.05     | 128.05     | 128.05     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084937   | 0.084937   | 0.084937   |   0.0 |  0.07
Output  | 0.00018614 | 0.00018614 | 0.00018614 |   0.0 |  0.00
Modify  | 0.37377    | 0.37377    | 0.37377    |   0.0 |  0.29
Other   |            | 0.05869    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3386.00 ave        3386 max        3386 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:      121022.0 ave      121022 max      121022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121022
Ave neighs/atom = 60.511000
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 = 294.030332060164, Press = 3.05607027931785
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -14786.589   -14786.589    -14864.22    -14864.22    300.43964    300.43964    36216.126    36216.126   -1245.1832   -1245.1832 
   20000   -14786.988   -14786.988     -14863.3     -14863.3    295.33296    295.33296    36244.256    36244.256   -2627.6354   -2627.6354 
Loop time of 127.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.301 hours/ns, 7.869 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    | 126.57     | 126.57     | 126.57     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084218   | 0.084218   | 0.084218   |   0.0 |  0.07
Output  | 0.00015197 | 0.00015197 | 0.00015197 |   0.0 |  0.00
Modify  | 0.36879    | 0.36879    | 0.36879    |   0.0 |  0.29
Other   |            | 0.05912    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3367.00 ave        3367 max        3367 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:      120976.0 ave      120976 max      120976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120976
Ave neighs/atom = 60.488000
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 = 293.931600006748, Press = 0.982290576758549
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -14786.988   -14786.988     -14863.3     -14863.3    295.33296    295.33296    36244.256    36244.256   -2627.6354   -2627.6354 
   21000   -14788.279   -14788.279   -14864.261   -14864.261    294.05906    294.05906    36226.838    36226.838   -1899.8807   -1899.8807 
Loop time of 127.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.543 hours/ns, 7.815 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    | 127.44     | 127.44     | 127.44     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084898   | 0.084898   | 0.084898   |   0.0 |  0.07
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.37303    | 0.37303    | 0.37303    |   0.0 |  0.29
Other   |            | 0.05868    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3404.00 ave        3404 max        3404 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:      120908.0 ave      120908 max      120908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120908
Ave neighs/atom = 60.454000
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 = 293.98290476706, Press = -0.444079308154231
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -14788.279   -14788.279   -14864.261   -14864.261    294.05906    294.05906    36226.838    36226.838   -1899.8807   -1899.8807 
   22000   -14784.137   -14784.137   -14861.056   -14861.056    297.68493    297.68493    36221.418    36221.418   -1281.3829   -1281.3829 
Loop time of 129.367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.935 hours/ns, 7.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.84     | 128.84     | 128.84     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084904   | 0.084904   | 0.084904   |   0.0 |  0.07
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.3826     | 0.3826     | 0.3826     |   0.0 |  0.30
Other   |            | 0.05923    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3333.00 ave        3333 max        3333 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:      120930.0 ave      120930 max      120930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120930
Ave neighs/atom = 60.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 = 293.953943051467, Press = -1.44256900673726
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -14784.137   -14784.137   -14861.056   -14861.056    297.68493    297.68493    36221.418    36221.418   -1281.3829   -1281.3829 
   23000   -14787.333   -14787.333    -14861.47    -14861.47     286.9186     286.9186    36199.273    36199.273   -228.95623   -228.95623 
Loop time of 130.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.131 hours/ns, 7.688 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    | 129.54     | 129.54     | 129.54     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085264   | 0.085264   | 0.085264   |   0.0 |  0.07
Output  | 0.00015659 | 0.00015659 | 0.00015659 |   0.0 |  0.00
Modify  | 0.38484    | 0.38484    | 0.38484    |   0.0 |  0.30
Other   |            | 0.06013    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3318.00 ave        3318 max        3318 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:      120988.0 ave      120988 max      120988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120988
Ave neighs/atom = 60.494000
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 = 294.067800892335, Press = -1.03258432488336
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -14787.333   -14787.333    -14861.47    -14861.47     286.9186     286.9186    36199.273    36199.273   -228.95623   -228.95623 
   24000   -14784.947   -14784.947   -14863.813   -14863.813    305.22132    305.22132     36203.49     36203.49      -552.25      -552.25 
Loop time of 130.203 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.167 hours/ns, 7.680 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    | 129.67     | 129.67     | 129.67     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085814   | 0.085814   | 0.085814   |   0.0 |  0.07
Output  | 0.00015511 | 0.00015511 | 0.00015511 |   0.0 |  0.00
Modify  | 0.38433    | 0.38433    | 0.38433    |   0.0 |  0.30
Other   |            | 0.05926    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 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:      121024.0 ave      121024 max      121024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121024
Ave neighs/atom = 60.512000
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 = 294.014426408914, Press = -0.00200876556823192
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -14784.947   -14784.947   -14863.813   -14863.813    305.22132    305.22132     36203.49     36203.49      -552.25      -552.25 
   25000    -14789.25    -14789.25   -14864.808   -14864.808    292.41454    292.41454    36198.976    36198.976   -477.28808   -477.28808 
Loop time of 131.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.562 hours/ns, 7.597 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    | 131.08     | 131.08     | 131.08     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087007   | 0.087007   | 0.087007   |   0.0 |  0.07
Output  | 0.00015807 | 0.00015807 | 0.00015807 |   0.0 |  0.00
Modify  | 0.39107    | 0.39107    | 0.39107    |   0.0 |  0.30
Other   |            | 0.05999    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 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:      120990.0 ave      120990 max      120990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120990
Ave neighs/atom = 60.495000
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 = 293.872649736937, Press = -0.452852782252168
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -14789.25    -14789.25   -14864.808   -14864.808    292.41454    292.41454    36198.976    36198.976   -477.28808   -477.28808 
   26000   -14783.485   -14783.485   -14860.719   -14860.719    298.90234    298.90234    36213.414    36213.414   -769.78601   -769.78601 
Loop time of 129.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.962 hours/ns, 7.724 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.95     | 128.95     | 128.95     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084577   | 0.084577   | 0.084577   |   0.0 |  0.07
Output  | 0.00017431 | 0.00017431 | 0.00017431 |   0.0 |  0.00
Modify  | 0.37325    | 0.37325    | 0.37325    |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 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:      121060.0 ave      121060 max      121060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121060
Ave neighs/atom = 60.530000
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 = 293.874590000277, Press = -0.613488451051871
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -14783.485   -14783.485   -14860.719   -14860.719    298.90234    298.90234    36213.414    36213.414   -769.78601   -769.78601 
   27000   -14786.984   -14786.984   -14862.218   -14862.218    291.16403    291.16403    36223.971    36223.971    -1585.894    -1585.894 
Loop time of 129.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.847 hours/ns, 7.749 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    | 128.52     | 128.52     | 128.52     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085234   | 0.085234   | 0.085234   |   0.0 |  0.07
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.38183    | 0.38183    | 0.38183    |   0.0 |  0.30
Other   |            | 0.05945    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3368.00 ave        3368 max        3368 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:      120980.0 ave      120980 max      120980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120980
Ave neighs/atom = 60.490000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.921877058549, Press = -2.14189258994071
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -14786.984   -14786.984   -14862.218   -14862.218    291.16403    291.16403    36223.971    36223.971    -1585.894    -1585.894 
   28000   -14784.524   -14784.524   -14862.565   -14862.565    302.02831    302.02831    36199.969    36199.969    -229.8643    -229.8643 
Loop time of 128.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.624 hours/ns, 7.797 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    | 127.73     | 127.73     | 127.73     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085195   | 0.085195   | 0.085195   |   0.0 |  0.07
Output  | 0.00015755 | 0.00015755 | 0.00015755 |   0.0 |  0.00
Modify  | 0.37648    | 0.37648    | 0.37648    |   0.0 |  0.29
Other   |            | 0.05861    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3356.00 ave        3356 max        3356 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:      120890.0 ave      120890 max      120890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120890
Ave neighs/atom = 60.445000
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 = 293.909677374631, Press = -2.57886150874678
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -14784.524   -14784.524   -14862.565   -14862.565    302.02831    302.02831    36199.969    36199.969    -229.8643    -229.8643 
   29000   -14787.812   -14787.812    -14862.97    -14862.97    290.86582    290.86582    36179.841    36179.841    710.35864    710.35864 
Loop time of 128.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.812 hours/ns, 7.757 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    | 128.4      | 128.4      | 128.4      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083887   | 0.083887   | 0.083887   |   0.0 |  0.07
Output  | 0.00019319 | 0.00019319 | 0.00019319 |   0.0 |  0.00
Modify  | 0.38031    | 0.38031    | 0.38031    |   0.0 |  0.29
Other   |            | 0.05939    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 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:      121014.0 ave      121014 max      121014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121014
Ave neighs/atom = 60.507000
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 = 293.797389919595, Press = -1.8533226406296
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -14787.812   -14787.812    -14862.97    -14862.97    290.86582    290.86582    36179.841    36179.841    710.35864    710.35864 
   30000   -14788.189   -14788.189   -14864.068   -14864.068    293.65973    293.65973     36173.46     36173.46    972.70956    972.70956 
Loop time of 129.014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.837 hours/ns, 7.751 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    | 128.49     | 128.49     | 128.49     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085133   | 0.085133   | 0.085133   |   0.0 |  0.07
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.38113    | 0.38113    | 0.38113    |   0.0 |  0.30
Other   |            | 0.06006    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3340.00 ave        3340 max        3340 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:      121056.0 ave      121056 max      121056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121056
Ave neighs/atom = 60.528000
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 = 293.745958594463, Press = -0.913749879182082
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -14788.189   -14788.189   -14864.068   -14864.068    293.65973    293.65973     36173.46     36173.46    972.70956    972.70956 
   31000   -14786.076   -14786.076   -14861.542   -14861.542    292.06055    292.06055    36170.197    36170.197    1397.3842    1397.3842 
Loop time of 129.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.079 hours/ns, 7.699 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    | 129.36     | 129.36     | 129.36     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086325   | 0.086325   | 0.086325   |   0.0 |  0.07
Output  | 0.00015609 | 0.00015609 | 0.00015609 |   0.0 |  0.00
Modify  | 0.38421    | 0.38421    | 0.38421    |   0.0 |  0.30
Other   |            | 0.06023    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3417.00 ave        3417 max        3417 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:      121096.0 ave      121096 max      121096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121096
Ave neighs/atom = 60.548000
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 = 293.595894084545, Press = -0.0817727527602464
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -14786.076   -14786.076   -14861.542   -14861.542    292.06055    292.06055    36170.197    36170.197    1397.3842    1397.3842 
   32000   -14787.764   -14787.764   -14863.837   -14863.837    294.41051    294.41051    36183.688    36183.688    437.19424    437.19424 
Loop time of 129.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.863 hours/ns, 7.745 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    | 128.58     | 128.58     | 128.58     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084575   | 0.084575   | 0.084575   |   0.0 |  0.07
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.38014    | 0.38014    | 0.38014    |   0.0 |  0.29
Other   |            | 0.05924    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      121156.0 ave      121156 max      121156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121156
Ave neighs/atom = 60.578000
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 = 293.664229136554, Press = 0.00695217879508315
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -14787.764   -14787.764   -14863.837   -14863.837    294.41051    294.41051    36183.688    36183.688    437.19424    437.19424 
   33000   -14783.054   -14783.054   -14861.847   -14861.847    304.93458    304.93458    36186.092    36186.092    534.56736    534.56736 
Loop time of 128.708 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.752 hours/ns, 7.770 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    | 128.19     | 128.19     | 128.19     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085055   | 0.085055   | 0.085055   |   0.0 |  0.07
Output  | 0.00015415 | 0.00015415 | 0.00015415 |   0.0 |  0.00
Modify  | 0.3774     | 0.3774     | 0.3774     |   0.0 |  0.29
Other   |            | 0.05897    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3374.00 ave        3374 max        3374 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:      121084.0 ave      121084 max      121084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121084
Ave neighs/atom = 60.542000
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 = 293.719005578875, Press = 0.127756504108535
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -14783.054   -14783.054   -14861.847   -14861.847    304.93458    304.93458    36186.092    36186.092    534.56736    534.56736 
   34000   -14787.316   -14787.316   -14863.037   -14863.037    293.04676    293.04676    36185.801    36185.801    317.97956    317.97956 
Loop time of 126.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.203 hours/ns, 7.891 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    | 126.22     | 126.22     | 126.22     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084578   | 0.084578   | 0.084578   |   0.0 |  0.07
Output  | 0.00015715 | 0.00015715 | 0.00015715 |   0.0 |  0.00
Modify  | 0.3714     | 0.3714     | 0.3714     |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3383.00 ave        3383 max        3383 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:      121032.0 ave      121032 max      121032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121032
Ave neighs/atom = 60.516000
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 = 293.761137245403, Press = -0.0712105332093368
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -14787.316   -14787.316   -14863.037   -14863.037    293.04676    293.04676    36185.801    36185.801    317.97956    317.97956 
   35000   -14789.453   -14789.453   -14863.094   -14863.094    284.99895    284.99895    36181.657    36181.657    489.98241    489.98241 
Loop time of 129.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.981 hours/ns, 7.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129        | 129        | 129        |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085844   | 0.085844   | 0.085844   |   0.0 |  0.07
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.38279    | 0.38279    | 0.38279    |   0.0 |  0.30
Other   |            | 0.05987    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      121046.0 ave      121046 max      121046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121046
Ave neighs/atom = 60.523000
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 = 293.77659086926, Press = -0.0589162458682922
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -14789.453   -14789.453   -14863.094   -14863.094    284.99895    284.99895    36181.657    36181.657    489.98241    489.98241 
   36000   -14785.435   -14785.435   -14864.545   -14864.545    306.16555    306.16555    36190.113    36190.113       111.06       111.06 
Loop time of 128.744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.762 hours/ns, 7.767 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    | 128.22     | 128.22     | 128.22     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085403   | 0.085403   | 0.085403   |   0.0 |  0.07
Output  | 0.00015629 | 0.00015629 | 0.00015629 |   0.0 |  0.00
Modify  | 0.3759     | 0.3759     | 0.3759     |   0.0 |  0.29
Other   |            | 0.05918    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3407.00 ave        3407 max        3407 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:      121110.0 ave      121110 max      121110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121110
Ave neighs/atom = 60.555000
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 = 293.704878438562, Press = 0.264780614137601
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -14785.435   -14785.435   -14864.545   -14864.545    306.16555    306.16555    36190.113    36190.113       111.06       111.06 
   37000   -14790.176   -14790.176   -14863.474   -14863.474    283.66807    283.66807      36196.3      36196.3   -289.67413   -289.67413 
Loop time of 126.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.260 hours/ns, 7.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.42     | 126.42     | 126.42     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082679   | 0.082679   | 0.082679   |   0.0 |  0.07
Output  | 0.00015761 | 0.00015761 | 0.00015761 |   0.0 |  0.00
Modify  | 0.37138    | 0.37138    | 0.37138    |   0.0 |  0.29
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3317.00 ave        3317 max        3317 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:      120970.0 ave      120970 max      120970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120970
Ave neighs/atom = 60.485000
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 = 293.596333476876, Press = 0.755243647924635
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -14790.176   -14790.176   -14863.474   -14863.474    283.66807    283.66807      36196.3      36196.3   -289.67413   -289.67413 
   38000   -14786.667   -14786.667   -14860.921   -14860.921    287.36938    287.36938    36230.843    36230.843   -1869.9724   -1869.9724 
Loop time of 131.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.573 hours/ns, 7.595 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    | 131.12     | 131.12     | 131.12     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086958   | 0.086958   | 0.086958   |   0.0 |  0.07
Output  | 0.00015606 | 0.00015606 | 0.00015606 |   0.0 |  0.00
Modify  | 0.39215    | 0.39215    | 0.39215    |   0.0 |  0.30
Other   |            | 0.06039    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3371.00 ave        3371 max        3371 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:      121026.0 ave      121026 max      121026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121026
Ave neighs/atom = 60.513000
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 = 293.564286065046, Press = 0.663332612068867
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -14786.667   -14786.667   -14860.921   -14860.921    287.36938    287.36938    36230.843    36230.843   -1869.9724   -1869.9724 
   39000   -14786.297   -14786.297   -14862.904   -14862.904    296.47697    296.47697    36244.391    36244.391   -2715.6452   -2715.6452 
Loop time of 128.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.621 hours/ns, 7.798 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.72     | 127.72     | 127.72     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08394    | 0.08394    | 0.08394    |   0.0 |  0.07
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.37308    | 0.37308    | 0.37308    |   0.0 |  0.29
Other   |            | 0.05852    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3359.00 ave        3359 max        3359 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:      120896.0 ave      120896 max      120896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120896
Ave neighs/atom = 60.448000
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 = 293.53003437935, Press = -0.192685171037865
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -14786.297   -14786.297   -14862.904   -14862.904    296.47697    296.47697    36244.391    36244.391   -2715.6452   -2715.6452 
   40000    -14789.45    -14789.45   -14864.593   -14864.593     290.8112     290.8112    36216.488    36216.488   -1410.4638   -1410.4638 
Loop time of 128.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.661 hours/ns, 7.789 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.85     | 127.85     | 127.85     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084007   | 0.084007   | 0.084007   |   0.0 |  0.07
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.38079    | 0.38079    | 0.38079    |   0.0 |  0.30
Other   |            | 0.05911    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3298.00 ave        3298 max        3298 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:      120958.0 ave      120958 max      120958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120958
Ave neighs/atom = 60.479000
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 = 293.506879353217, Press = -0.566242805654785
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -14789.45    -14789.45   -14864.593   -14864.593     290.8112     290.8112    36216.488    36216.488   -1410.4638   -1410.4638 
   41000   -14785.828   -14785.828   -14862.432   -14862.432    296.46479    296.46479    36202.766    36202.766    -501.3607    -501.3607 
Loop time of 126.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.127 hours/ns, 7.908 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    | 125.94     | 125.94     | 125.94     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084181   | 0.084181   | 0.084181   |   0.0 |  0.07
Output  | 0.00042042 | 0.00042042 | 0.00042042 |   0.0 |  0.00
Modify  | 0.3695     | 0.3695     | 0.3695     |   0.0 |  0.29
Other   |            | 0.05861    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3346.00 ave        3346 max        3346 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:      120880.0 ave      120880 max      120880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120880
Ave neighs/atom = 60.440000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.444788182033, Press = -0.517271068001897
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -14785.828   -14785.828   -14862.432   -14862.432    296.46479    296.46479    36202.766    36202.766    -501.3607    -501.3607 
   42000   -14790.808   -14790.808   -14864.667   -14864.667    285.84082    285.84082    36196.428    36196.428   -507.27456   -507.27456 
Loop time of 128.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.797 hours/ns, 7.760 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.35     | 128.35     | 128.35     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084571   | 0.084571   | 0.084571   |   0.0 |  0.07
Output  | 0.00019873 | 0.00019873 | 0.00019873 |   0.0 |  0.00
Modify  | 0.37734    | 0.37734    | 0.37734    |   0.0 |  0.29
Other   |            | 0.0596     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3354.00 ave        3354 max        3354 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:      121004.0 ave      121004 max      121004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121004
Ave neighs/atom = 60.502000
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 = 293.371285275114, Press = -0.588169592493194
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -14790.808   -14790.808   -14864.667   -14864.667    285.84082    285.84082    36196.428    36196.428   -507.27456   -507.27456 
   43000    -14785.64    -14785.64   -14862.636   -14862.636    297.98323    297.98323    36202.136    36202.136   -436.90796   -436.90796 
Loop time of 128.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.805 hours/ns, 7.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.37     | 128.37     | 128.37     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08529    | 0.08529    | 0.08529    |   0.0 |  0.07
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.38007    | 0.38007    | 0.38007    |   0.0 |  0.29
Other   |            | 0.0596     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3380.00 ave        3380 max        3380 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:      120998.0 ave      120998 max      120998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120998
Ave neighs/atom = 60.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 = 293.328117564051, Press = -0.796735946405327
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    -14785.64    -14785.64   -14862.636   -14862.636    297.98323    297.98323    36202.136    36202.136   -436.90796   -436.90796 
   44000   -14788.367   -14788.367    -14864.71    -14864.71    295.45443    295.45443     36170.93     36170.93    1011.0433    1011.0433 
Loop time of 128.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.716 hours/ns, 7.777 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    | 128.06     | 128.06     | 128.06     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084689   | 0.084689   | 0.084689   |   0.0 |  0.07
Output  | 0.00015312 | 0.00015312 | 0.00015312 |   0.0 |  0.00
Modify  | 0.37675    | 0.37675    | 0.37675    |   0.0 |  0.29
Other   |            | 0.05886    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3354.00 ave        3354 max        3354 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:      120966.0 ave      120966 max      120966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120966
Ave neighs/atom = 60.483000
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 = 293.32558784968, Press = -1.78399028579421
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -14788.367   -14788.367    -14864.71    -14864.71    295.45443    295.45443     36170.93     36170.93    1011.0433    1011.0433 
   45000   -14786.023   -14786.023   -14864.628   -14864.628    304.20988    304.20988    36143.503    36143.503    2535.6568    2535.6568 
Loop time of 128.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.593 hours/ns, 7.804 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    | 127.62     | 127.62     | 127.62     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084284   | 0.084284   | 0.084284   |   0.0 |  0.07
Output  | 0.00023246 | 0.00023246 | 0.00023246 |   0.0 |  0.00
Modify  | 0.37451    | 0.37451    | 0.37451    |   0.0 |  0.29
Other   |            | 0.05939    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 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:      121090.0 ave      121090 max      121090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121090
Ave neighs/atom = 60.545000
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 = 293.382578691236, Press = -1.1706505606194
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -14786.023   -14786.023   -14864.628   -14864.628    304.20988    304.20988    36143.503    36143.503    2535.6568    2535.6568 
   46000   -14784.152   -14784.152   -14860.789   -14860.789    296.59138    296.59138    36156.285    36156.285    2208.3763    2208.3763 
Loop time of 128.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.685 hours/ns, 7.784 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.95     | 127.95     | 127.95     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084615   | 0.084615   | 0.084615   |   0.0 |  0.07
Output  | 0.0001528  | 0.0001528  | 0.0001528  |   0.0 |  0.00
Modify  | 0.37661    | 0.37661    | 0.37661    |   0.0 |  0.29
Other   |            | 0.05941    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3360.00 ave        3360 max        3360 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:      121200.0 ave      121200 max      121200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121200
Ave neighs/atom = 60.600000
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 = 293.407161611945, Press = -0.203553616311078
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -14784.152   -14784.152   -14860.789   -14860.789    296.59138    296.59138    36156.285    36156.285    2208.3763    2208.3763 
   47000   -14787.942   -14787.942   -14862.679   -14862.679    289.24017    289.24017    36169.894    36169.894    1198.4848    1198.4848 
Loop time of 129.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.098 hours/ns, 7.695 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.42     | 129.42     | 129.42     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085714   | 0.085714   | 0.085714   |   0.0 |  0.07
Output  | 0.00019388 | 0.00019388 | 0.00019388 |   0.0 |  0.00
Modify  | 0.38513    | 0.38513    | 0.38513    |   0.0 |  0.30
Other   |            | 0.05994    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3372.00 ave        3372 max        3372 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:      121104.0 ave      121104 max      121104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121104
Ave neighs/atom = 60.552000
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 = 293.408826812404, Press = 0.288560390329094
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -14787.942   -14787.942   -14862.679   -14862.679    289.24017    289.24017    36169.894    36169.894    1198.4848    1198.4848 
   48000    -14788.57    -14788.57   -14862.572   -14862.572    286.39485    286.39485    36184.161    36184.161    433.24403    433.24403 
Loop time of 127.274 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.354 hours/ns, 7.857 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    | 126.76     | 126.76     | 126.76     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084462   | 0.084462   | 0.084462   |   0.0 |  0.07
Output  | 0.00016097 | 0.00016097 | 0.00016097 |   0.0 |  0.00
Modify  | 0.37381    | 0.37381    | 0.37381    |   0.0 |  0.29
Other   |            | 0.05862    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3342.00 ave        3342 max        3342 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:      121136.0 ave      121136 max      121136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121136
Ave neighs/atom = 60.568000
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 = 293.386042246794, Press = 0.33402855772301
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -14788.57    -14788.57   -14862.572   -14862.572    286.39485    286.39485    36184.161    36184.161    433.24403    433.24403 
   49000   -14785.344   -14785.344   -14861.501   -14861.501    294.73209    294.73209    36204.628    36204.628   -449.89153   -449.89153 
Loop time of 126.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.247 hours/ns, 7.881 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.38     | 126.38     | 126.38     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084117   | 0.084117   | 0.084117   |   0.0 |  0.07
Output  | 0.0001529  | 0.0001529  | 0.0001529  |   0.0 |  0.00
Modify  | 0.3714     | 0.3714     | 0.3714     |   0.0 |  0.29
Other   |            | 0.05858    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 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:      121084.0 ave      121084 max      121084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121084
Ave neighs/atom = 60.542000
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 = 293.315097916277, Press = 0.4894371108759
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -14785.344   -14785.344   -14861.501   -14861.501    294.73209    294.73209    36204.628    36204.628   -449.89153   -449.89153 
   50000   -14788.324   -14788.324   -14864.731   -14864.731    295.70077    295.70077    36249.487    36249.487   -3158.1851   -3158.1851 
Loop time of 127.341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.372 hours/ns, 7.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.83     | 126.83     | 126.83     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084165   | 0.084165   | 0.084165   |   0.0 |  0.07
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.37093    | 0.37093    | 0.37093    |   0.0 |  0.29
Other   |            | 0.05852    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3383.00 ave        3383 max        3383 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:      121002.0 ave      121002 max      121002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121002
Ave neighs/atom = 60.501000
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 = 293.289784304096, Press = 0.69863361547539
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 = 6.6
  ghost atom cutoff = 6.6
  binsize = 3.3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -14788.324   -14788.324   -14864.731   -14864.731    295.70077    295.70077    36249.487    36249.487   -3158.1851   -3158.1851 
   51000   -14787.346   -14787.346   -14862.584   -14862.584    291.17637    291.17637    36242.294    36242.294   -2635.5887   -2635.5887 
Loop time of 127.698 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.472 hours/ns, 7.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.18     | 127.18     | 127.18     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084522   | 0.084522   | 0.084522   |   0.0 |  0.07
Output  | 0.00015477 | 0.00015477 | 0.00015477 |   0.0 |  0.00
Modify  | 0.37675    | 0.37675    | 0.37675    |   0.0 |  0.30
Other   |            | 0.06007    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3371.00 ave        3371 max        3371 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:      120822.0 ave      120822 max      120822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120822
Ave neighs/atom = 60.411000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
36193.8632531634

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0