# 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.031088918447495*${_u_distance}
variable latticeconst_converted equal 3.031088918447495*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891844749
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
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 (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.001 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_V__MO_868364924829_000
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.1295338222 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_868364924829_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -10524.253   -10524.253       -10600       -10600       293.15       293.15     27848.13     27848.13    2905.2857    2905.2857 
    1000   -10441.975   -10441.975   -10524.377   -10524.377    318.90485    318.90485    28071.737    28071.737   -1736.8514   -1736.8514 
Loop time of 59.3616 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.455 ns/day, 16.489 hours/ns, 16.846 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    | 59.029     | 59.029     | 59.029     |   0.0 | 99.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043266   | 0.043266   | 0.043266   |   0.0 |  0.07
Output  | 0.00054722 | 0.00054722 | 0.00054722 |   0.0 |  0.00
Modify  | 0.25048    | 0.25048    | 0.25048    |   0.0 |  0.42
Other   |            | 0.03877    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.128 ns/day, 21.285 hours/ns, 13.051 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 76.235     | 76.235     | 76.235     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052657   | 0.052657   | 0.052657   |   0.0 |  0.07
Output  | 0.00020967 | 0.00020967 | 0.00020967 |   0.0 |  0.00
Modify  | 0.29562    | 0.29562    | 0.29562    |   0.0 |  0.39
Other   |            | 0.04195    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.101 ns/day, 21.805 hours/ns, 12.739 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    | 78.103     | 78.103     | 78.103     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053775   | 0.053775   | 0.053775   |   0.0 |  0.07
Output  | 0.00020639 | 0.00020639 | 0.00020639 |   0.0 |  0.00
Modify  | 0.29993    | 0.29993    | 0.29993    |   0.0 |  0.38
Other   |            | 0.04078    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.114 ns/day, 21.542 hours/ns, 12.895 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    | 77.16      | 77.16      | 77.16      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05299    | 0.05299    | 0.05299    |   0.0 |  0.07
Output  | 0.00021047 | 0.00021047 | 0.00021047 |   0.0 |  0.00
Modify  | 0.29593    | 0.29593    | 0.29593    |   0.0 |  0.38
Other   |            | 0.03993    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.101 ns/day, 21.804 hours/ns, 12.739 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    | 78.1       | 78.1       | 78.1       |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053603   | 0.053603   | 0.053603   |   0.0 |  0.07
Output  | 0.0001094  | 0.0001094  | 0.0001094  |   0.0 |  0.00
Modify  | 0.30116    | 0.30116    | 0.30116    |   0.0 |  0.38
Other   |            | 0.04104    |            |       |  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:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.108 ns/day, 21.669 hours/ns, 12.819 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    | 77.603     | 77.603     | 77.603     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053597   | 0.053597   | 0.053597   |   0.0 |  0.07
Output  | 0.00016773 | 0.00016773 | 0.00016773 |   0.0 |  0.00
Modify  | 0.30914    | 0.30914    | 0.30914    |   0.0 |  0.40
Other   |            | 0.04054    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.65280093777, Press = -15.5008692928491
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -10443.606   -10443.606   -10519.753   -10519.753    294.69654    294.69654    27977.763    27977.763    3614.8195    3614.8195 
    7000   -10445.146   -10445.146   -10519.389   -10519.389    287.32636    287.32636    28043.468    28043.468   -113.98132   -113.98132 
Loop time of 77.9347 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.109 ns/day, 21.649 hours/ns, 12.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    | 77.532     | 77.532     | 77.532     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053129   | 0.053129   | 0.053129   |   0.0 |  0.07
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.30956    | 0.30956    | 0.30956    |   0.0 |  0.40
Other   |            | 0.04022    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845735770497, Press = 34.5487036760294
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -10445.146   -10445.146   -10519.389   -10519.389    287.32636    287.32636    28043.468    28043.468   -113.98132   -113.98132 
    8000     -10444.2     -10444.2   -10519.861   -10519.861    292.81595    292.81595    28062.276    28062.276   -1083.8128   -1083.8128 
Loop time of 78.5244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.100 ns/day, 21.812 hours/ns, 12.735 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    | 78.116     | 78.116     | 78.116     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053924   | 0.053924   | 0.053924   |   0.0 |  0.07
Output  | 0.00010749 | 0.00010749 | 0.00010749 |   0.0 |  0.00
Modify  | 0.31297    | 0.31297    | 0.31297    |   0.0 |  0.40
Other   |            | 0.04089    |            |       |  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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.494239966109, Press = -1.99468144166268
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000     -10444.2     -10444.2   -10519.861   -10519.861    292.81595    292.81595    28062.276    28062.276   -1083.8128   -1083.8128 
    9000   -10443.852   -10443.852   -10518.231   -10518.231    287.85433    287.85433    28011.474    28011.474     1602.285     1602.285 
Loop time of 77.2817 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.467 hours/ns, 12.940 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    | 76.887     | 76.887     | 76.887     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052108   | 0.052108   | 0.052108   |   0.0 |  0.07
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.30341    | 0.30341    | 0.30341    |   0.0 |  0.39
Other   |            | 0.03902    |            |       |  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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.038110442141, Press = 4.6048911886614
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -10443.852   -10443.852   -10518.231   -10518.231    287.85433    287.85433    28011.474    28011.474     1602.285     1602.285 
   10000   -10444.111   -10444.111   -10518.913   -10518.913    289.49272    289.49272    28049.631    28049.631   -489.35991   -489.35991 
Loop time of 77.4651 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.115 ns/day, 21.518 hours/ns, 12.909 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    | 77.07      | 77.07      | 77.07      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052282   | 0.052282   | 0.052282   |   0.0 |  0.07
Output  | 0.0001542  | 0.0001542  | 0.0001542  |   0.0 |  0.00
Modify  | 0.30371    | 0.30371    | 0.30371    |   0.0 |  0.39
Other   |            | 0.03897    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.550915198074, Press = 13.568819258197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -10444.111   -10444.111   -10518.913   -10518.913    289.49272    289.49272    28049.631    28049.631   -489.35991   -489.35991 
   11000   -10444.965   -10444.965    -10522.43    -10522.43    299.79653    299.79653    28088.758    28088.758   -2685.1504   -2685.1504 
Loop time of 77.2299 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.453 hours/ns, 12.948 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    | 76.836     | 76.836     | 76.836     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052121   | 0.052121   | 0.052121   |   0.0 |  0.07
Output  | 0.00010537 | 0.00010537 | 0.00010537 |   0.0 |  0.00
Modify  | 0.30304    | 0.30304    | 0.30304    |   0.0 |  0.39
Other   |            | 0.03889    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.634748512166, Press = -10.4785980277251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -10444.965   -10444.965    -10522.43    -10522.43    299.79653    299.79653    28088.758    28088.758   -2685.1504   -2685.1504 
   12000   -10441.982   -10441.982   -10520.562   -10520.562    304.10974    304.10974    27987.443    27987.443    2937.9691    2937.9691 
Loop time of 77.3654 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.490 hours/ns, 12.926 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    | 76.972     | 76.972     | 76.972     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052127   | 0.052127   | 0.052127   |   0.0 |  0.07
Output  | 0.00014736 | 0.00014736 | 0.00014736 |   0.0 |  0.00
Modify  | 0.30186    | 0.30186    | 0.30186    |   0.0 |  0.39
Other   |            | 0.0389     |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.636903211219, Press = 2.04924704253579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -10441.982   -10441.982   -10520.562   -10520.562    304.10974    304.10974    27987.443    27987.443    2937.9691    2937.9691 
   13000   -10446.568   -10446.568   -10520.527   -10520.527    286.22865    286.22865    28048.463    28048.463   -303.73171   -303.73171 
Loop time of 77.3609 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.489 hours/ns, 12.926 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    | 76.967     | 76.967     | 76.967     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052383   | 0.052383   | 0.052383   |   0.0 |  0.07
Output  | 0.00015087 | 0.00015087 | 0.00015087 |   0.0 |  0.00
Modify  | 0.30186    | 0.30186    | 0.30186    |   0.0 |  0.39
Other   |            | 0.03907    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740562659411, Press = 7.76229659534185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -10446.568   -10446.568   -10520.527   -10520.527    286.22865    286.22865    28048.463    28048.463   -303.73171   -303.73171 
   14000   -10443.418   -10443.418   -10521.413   -10521.413    301.85173    301.85173    28061.655    28061.655   -998.31644   -998.31644 
Loop time of 77.3732 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.493 hours/ns, 12.924 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    | 76.981     | 76.981     | 76.981     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05211    | 0.05211    | 0.05211    |   0.0 |  0.07
Output  | 9.9139e-05 | 9.9139e-05 | 9.9139e-05 |   0.0 |  0.00
Modify  | 0.30129    | 0.30129    | 0.30129    |   0.0 |  0.39
Other   |            | 0.03883    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.00845472209, Press = 0.686111154195141
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -10443.418   -10443.418   -10521.413   -10521.413    301.85173    301.85173    28061.655    28061.655   -998.31644   -998.31644 
   15000   -10446.691   -10446.691   -10521.744   -10521.744    290.46198    290.46198    28013.605    28013.605    1392.8497    1392.8497 
Loop time of 77.4647 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.115 ns/day, 21.518 hours/ns, 12.909 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    | 77.072     | 77.072     | 77.072     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052088   | 0.052088   | 0.052088   |   0.0 |  0.07
Output  | 0.00016979 | 0.00016979 | 0.00016979 |   0.0 |  0.00
Modify  | 0.30162    | 0.30162    | 0.30162    |   0.0 |  0.39
Other   |            | 0.0388     |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.182029373516, Press = 2.47212160492062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -10446.691   -10446.691   -10521.744   -10521.744    290.46198    290.46198    28013.605    28013.605    1392.8497    1392.8497 
   16000   -10442.112   -10442.112   -10520.706   -10520.706    304.16848    304.16848    28059.381    28059.381   -802.31309   -802.31309 
Loop time of 77.2448 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.457 hours/ns, 12.946 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    | 76.852     | 76.852     | 76.852     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052028   | 0.052028   | 0.052028   |   0.0 |  0.07
Output  | 0.00015995 | 0.00015995 | 0.00015995 |   0.0 |  0.00
Modify  | 0.30184    | 0.30184    | 0.30184    |   0.0 |  0.39
Other   |            | 0.03895    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.333869249123, Press = 7.98397566144144
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -10442.112   -10442.112   -10520.706   -10520.706    304.16848    304.16848    28059.381    28059.381   -802.31309   -802.31309 
   17000   -10445.753   -10445.753   -10521.047   -10521.047    291.39732    291.39732    28085.296    28085.296   -2520.0441   -2520.0441 
Loop time of 77.2387 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.455 hours/ns, 12.947 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    | 76.846     | 76.846     | 76.846     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052234   | 0.052234   | 0.052234   |   0.0 |  0.07
Output  | 0.00010433 | 0.00010433 | 0.00010433 |   0.0 |  0.00
Modify  | 0.30196    | 0.30196    | 0.30196    |   0.0 |  0.39
Other   |            | 0.03885    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38748440897, Press = -3.09088591802411
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -10445.753   -10445.753   -10521.047   -10521.047    291.39732    291.39732    28085.296    28085.296   -2520.0441   -2520.0441 
   18000   -10443.579   -10443.579   -10518.666   -10518.666    290.59349    290.59349    27996.029    27996.029    2508.3495    2508.3495 
Loop time of 77.5481 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.114 ns/day, 21.541 hours/ns, 12.895 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    | 77.155     | 77.155     | 77.155     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05222    | 0.05222    | 0.05222    |   0.0 |  0.07
Output  | 0.0001607  | 0.0001607  | 0.0001607  |   0.0 |  0.00
Modify  | 0.30158    | 0.30158    | 0.30158    |   0.0 |  0.39
Other   |            | 0.03912    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.255719866135, Press = 1.00805663737494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -10443.579   -10443.579   -10518.666   -10518.666    290.59349    290.59349    27996.029    27996.029    2508.3495    2508.3495 
   19000   -10446.563   -10446.563   -10521.544   -10521.544    290.18469    290.18469    28045.223    28045.223   -368.80924   -368.80924 
Loop time of 77.526 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.114 ns/day, 21.535 hours/ns, 12.899 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    | 77.133     | 77.133     | 77.133     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052044   | 0.052044   | 0.052044   |   0.0 |  0.07
Output  | 9.7683e-05 | 9.7683e-05 | 9.7683e-05 |   0.0 |  0.00
Modify  | 0.30203    | 0.30203    | 0.30203    |   0.0 |  0.39
Other   |            | 0.03895    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1002164009, Press = 5.91334231146402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -10446.563   -10446.563   -10521.544   -10521.544    290.18469    290.18469    28045.223    28045.223   -368.80924   -368.80924 
   20000   -10444.015   -10444.015   -10520.206   -10520.206    294.86656    294.86656    28072.303    28072.303   -1738.8549   -1738.8549 
Loop time of 77.3074 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.474 hours/ns, 12.935 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    | 76.915     | 76.915     | 76.915     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051942   | 0.051942   | 0.051942   |   0.0 |  0.07
Output  | 0.00014786 | 0.00014786 | 0.00014786 |   0.0 |  0.00
Modify  | 0.30169    | 0.30169    | 0.30169    |   0.0 |  0.39
Other   |            | 0.03902    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.070844220163, Press = 0.37824699743457
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -10444.015   -10444.015   -10520.206   -10520.206    294.86656    294.86656    28072.303    28072.303   -1738.8549   -1738.8549 
   21000   -10446.557   -10446.557   -10520.039   -10520.039    284.38125    284.38125    28008.709    28008.709    1663.1192    1663.1192 
Loop time of 77.1978 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.444 hours/ns, 12.954 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    | 76.804     | 76.804     | 76.804     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052203   | 0.052203   | 0.052203   |   0.0 |  0.07
Output  | 0.00015242 | 0.00015242 | 0.00015242 |   0.0 |  0.00
Modify  | 0.30199    | 0.30199    | 0.30199    |   0.0 |  0.39
Other   |            | 0.03963    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915293490525, Press = 1.15023638833917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -10446.557   -10446.557   -10520.039   -10520.039    284.38125    284.38125    28008.709    28008.709    1663.1192    1663.1192 
   22000   -10445.419   -10445.419   -10521.337   -10521.337    293.80953    293.80953    28051.229    28051.229   -679.71061   -679.71061 
Loop time of 77.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.496 hours/ns, 12.922 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    | 76.992     | 76.992     | 76.992     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052044   | 0.052044   | 0.052044   |   0.0 |  0.07
Output  | 9.8168e-05 | 9.8168e-05 | 9.8168e-05 |   0.0 |  0.00
Modify  | 0.30215    | 0.30215    | 0.30215    |   0.0 |  0.39
Other   |            | 0.03899    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870059914988, Press = 4.96006545864049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -10445.419   -10445.419   -10521.337   -10521.337    293.80953    293.80953    28051.229    28051.229   -679.71061   -679.71061 
   23000   -10444.215   -10444.215    -10519.48    -10519.48    291.28167    291.28167     28092.57     28092.57   -2747.8748   -2747.8748 
Loop time of 77.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.502 hours/ns, 12.919 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    | 77.013     | 77.013     | 77.013     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0523     | 0.0523     | 0.0523     |   0.0 |  0.07
Output  | 0.00014619 | 0.00014619 | 0.00014619 |   0.0 |  0.00
Modify  | 0.30178    | 0.30178    | 0.30178    |   0.0 |  0.39
Other   |            | 0.03902    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855566539757, Press = -2.52808988065257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -10444.215   -10444.215    -10519.48    -10519.48    291.28167    291.28167     28092.57     28092.57   -2747.8748   -2747.8748 
   24000   -10448.807   -10448.807   -10522.522   -10522.522    285.28687    285.28687    27993.269    27993.269    2325.3093    2325.3093 
Loop time of 77.3241 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.479 hours/ns, 12.933 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    | 76.931     | 76.931     | 76.931     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052276   | 0.052276   | 0.052276   |   0.0 |  0.07
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.30163    | 0.30163    | 0.30163    |   0.0 |  0.39
Other   |            | 0.03893    |            |       |  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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.801219516151, Press = 1.35004211192202
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -10448.807   -10448.807   -10522.522   -10522.522    285.28687    285.28687    27993.269    27993.269    2325.3093    2325.3093 
   25000   -10444.873   -10444.873   -10521.712   -10521.712    297.37287    297.37287    28047.772    28047.772   -548.16338   -548.16338 
Loop time of 57.6192 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.499 ns/day, 16.005 hours/ns, 17.355 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    | 57.301     | 57.301     | 57.301     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039603   | 0.039603   | 0.039603   |   0.0 |  0.07
Output  | 0.00011852 | 0.00011852 | 0.00011852 |   0.0 |  0.00
Modify  | 0.24142    | 0.24142    | 0.24142    |   0.0 |  0.42
Other   |            | 0.03691    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.742818387826, Press = 3.58034743252121
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -10444.873   -10444.873   -10521.712   -10521.712    297.37287    297.37287    28047.772    28047.772   -548.16338   -548.16338 
   26000   -10446.441   -10446.441   -10521.139   -10521.139    289.08935    289.08935      28058.8      28058.8   -1113.3891   -1113.3891 
Loop time of 57.131 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.512 ns/day, 15.870 hours/ns, 17.504 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    | 56.815     | 56.815     | 56.815     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039297   | 0.039297   | 0.039297   |   0.0 |  0.07
Output  | 0.00033302 | 0.00033302 | 0.00033302 |   0.0 |  0.00
Modify  | 0.23986    | 0.23986    | 0.23986    |   0.0 |  0.42
Other   |            | 0.03614    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.847955784021, Press = 0.119142916815577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -10446.441   -10446.441   -10521.139   -10521.139    289.08935    289.08935      28058.8      28058.8   -1113.3891   -1113.3891 
   27000   -10443.269   -10443.269   -10520.556   -10520.556    299.10592    299.10592    28007.393    28007.393    1819.0263    1819.0263 
Loop time of 59.6091 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.558 hours/ns, 16.776 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    | 59.279     | 59.279     | 59.279     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040675   | 0.040675   | 0.040675   |   0.0 |  0.07
Output  | 0.00010164 | 0.00010164 | 0.00010164 |   0.0 |  0.00
Modify  | 0.25117    | 0.25117    | 0.25117    |   0.0 |  0.42
Other   |            | 0.03809    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815840953337, Press = 1.13225082663181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -10443.269   -10443.269   -10520.556   -10520.556    299.10592    299.10592    28007.393    28007.393    1819.0263    1819.0263 
   28000   -10446.344   -10446.344   -10522.025   -10522.025    292.89505    292.89505    28060.234    28060.234   -1295.3952   -1295.3952 
Loop time of 55.9918 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.543 ns/day, 15.553 hours/ns, 17.860 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    | 55.685     | 55.685     | 55.685     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038561   | 0.038561   | 0.038561   |   0.0 |  0.07
Output  | 0.00014874 | 0.00014874 | 0.00014874 |   0.0 |  0.00
Modify  | 0.23314    | 0.23314    | 0.23314    |   0.0 |  0.42
Other   |            | 0.03505    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.745980624366, Press = 5.47143851019867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -10446.344   -10446.344   -10522.025   -10522.025    292.89505    292.89505    28060.234    28060.234   -1295.3952   -1295.3952 
   29000   -10444.154   -10444.154   -10521.366   -10521.366    298.81869    298.81869    28092.641    28092.641   -2961.8738   -2961.8738 
Loop time of 69.4518 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.244 ns/day, 19.292 hours/ns, 14.398 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    | 69.087     | 69.087     | 69.087     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04776    | 0.04776    | 0.04776    |   0.0 |  0.07
Output  | 0.00015698 | 0.00015698 | 0.00015698 |   0.0 |  0.00
Modify  | 0.27819    | 0.27819    | 0.27819    |   0.0 |  0.40
Other   |            | 0.03871    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778842982058, Press = -1.56518292159915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -10444.154   -10444.154   -10521.366   -10521.366    298.81869    298.81869    28092.641    28092.641   -2961.8738   -2961.8738 
   30000   -10448.062   -10448.062   -10522.824   -10522.824    289.33538    289.33538     27997.45     27997.45    2006.1924    2006.1924 
Loop time of 77.3773 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.494 hours/ns, 12.924 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    | 76.986     | 76.986     | 76.986     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052384   | 0.052384   | 0.052384   |   0.0 |  0.07
Output  | 0.00016723 | 0.00016723 | 0.00016723 |   0.0 |  0.00
Modify  | 0.29981    | 0.29981    | 0.29981    |   0.0 |  0.39
Other   |            | 0.03912    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.676415882904, Press = 1.48586176041155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -10448.062   -10448.062   -10522.824   -10522.824    289.33538    289.33538     27997.45     27997.45    2006.1924    2006.1924 
   31000   -10444.204   -10444.204   -10523.119   -10523.119    305.40767    305.40767    28048.683    28048.683   -542.26399   -542.26399 
Loop time of 77.0165 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.122 ns/day, 21.393 hours/ns, 12.984 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    | 76.625     | 76.625     | 76.625     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052101   | 0.052101   | 0.052101   |   0.0 |  0.07
Output  | 0.00015749 | 0.00015749 | 0.00015749 |   0.0 |  0.00
Modify  | 0.30001    | 0.30001    | 0.30001    |   0.0 |  0.39
Other   |            | 0.03893    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.683931441625, Press = 3.04139585415665
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -10444.204   -10444.204   -10523.119   -10523.119    305.40767    305.40767    28048.683    28048.683   -542.26399   -542.26399 
   32000   -10442.363   -10442.363   -10518.111   -10518.111    293.15484    293.15484    28068.469    28068.469   -1269.4815   -1269.4815 
Loop time of 74.5701 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.159 ns/day, 20.714 hours/ns, 13.410 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    | 74.189     | 74.189     | 74.189     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050705   | 0.050705   | 0.050705   |   0.0 |  0.07
Output  | 0.00016744 | 0.00016744 | 0.00016744 |   0.0 |  0.00
Modify  | 0.29183    | 0.29183    | 0.29183    |   0.0 |  0.39
Other   |            | 0.03888    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.653363093456, Press = 0.389376464467867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -10442.363   -10442.363   -10518.111   -10518.111    293.15484    293.15484    28068.469    28068.469   -1269.4815   -1269.4815 
   33000     -10443.8     -10443.8    -10521.85    -10521.85    302.06341    302.06341    28016.067    28016.067    1199.8154    1199.8154 
Loop time of 73.2697 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.179 ns/day, 20.353 hours/ns, 13.648 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    | 72.891     | 72.891     | 72.891     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04996    | 0.04996    | 0.04996    |   0.0 |  0.07
Output  | 0.00035144 | 0.00035144 | 0.00035144 |   0.0 |  0.00
Modify  | 0.28906    | 0.28906    | 0.28906    |   0.0 |  0.39
Other   |            | 0.03882    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.616678268202, Press = 1.03737534754319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000     -10443.8     -10443.8    -10521.85    -10521.85    302.06341    302.06341    28016.067    28016.067    1199.8154    1199.8154 
   34000    -10444.29    -10444.29   -10520.108   -10520.108    293.42257    293.42257    28041.523    28041.523   -28.753778   -28.753778 
Loop time of 77.3871 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.496 hours/ns, 12.922 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    | 76.996     | 76.996     | 76.996     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052271   | 0.052271   | 0.052271   |   0.0 |  0.07
Output  | 0.00014915 | 0.00014915 | 0.00014915 |   0.0 |  0.00
Modify  | 0.30005    | 0.30005    | 0.30005    |   0.0 |  0.39
Other   |            | 0.03909    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.573642832876, Press = 3.00704235100327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -10444.29    -10444.29   -10520.108   -10520.108    293.42257    293.42257    28041.523    28041.523   -28.753778   -28.753778 
   35000   -10447.182   -10447.182   -10519.897   -10519.897    281.41458    281.41458    28079.694    28079.694   -2204.0387   -2204.0387 
Loop time of 77.3858 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.496 hours/ns, 12.922 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    | 76.996     | 76.996     | 76.996     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051835   | 0.051835   | 0.051835   |   0.0 |  0.07
Output  | 0.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.29888    | 0.29888    | 0.29888    |   0.0 |  0.39
Other   |            | 0.03874    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.57316389532, Press = -0.158697386216487
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -10447.182   -10447.182   -10519.897   -10519.897    281.41458    281.41458    28079.694    28079.694   -2204.0387   -2204.0387 
   36000   -10442.845   -10442.845   -10519.048   -10519.048    294.91407    294.91407    27983.524    27983.524    3284.6451    3284.6451 
Loop time of 77.3835 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.495 hours/ns, 12.923 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    | 76.993     | 76.993     | 76.993     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052163   | 0.052163   | 0.052163   |   0.0 |  0.07
Output  | 0.00016771 | 0.00016771 | 0.00016771 |   0.0 |  0.00
Modify  | 0.29914    | 0.29914    | 0.29914    |   0.0 |  0.39
Other   |            | 0.03894    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.554800639207, Press = 0.235875013945884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -10442.845   -10442.845   -10519.048   -10519.048    294.91407    294.91407    27983.524    27983.524    3284.6451    3284.6451 
   37000   -10443.307   -10443.307   -10519.476   -10519.476    294.78245    294.78245     28041.93     28041.93    150.27306    150.27306 
Loop time of 77.3305 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.481 hours/ns, 12.932 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    | 76.94      | 76.94      | 76.94      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052449   | 0.052449   | 0.052449   |   0.0 |  0.07
Output  | 0.00016537 | 0.00016537 | 0.00016537 |   0.0 |  0.00
Modify  | 0.29891    | 0.29891    | 0.29891    |   0.0 |  0.39
Other   |            | 0.03865    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.568897504132, Press = 2.92356358986349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -10443.307   -10443.307   -10519.476   -10519.476    294.78245    294.78245     28041.93     28041.93    150.27306    150.27306 
   38000   -10443.855   -10443.855   -10519.886   -10519.886    294.24981    294.24981    28060.111    28060.111   -1070.9201   -1070.9201 
Loop time of 77.3286 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.480 hours/ns, 12.932 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    | 76.939     | 76.939     | 76.939     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052179   | 0.052179   | 0.052179   |   0.0 |  0.07
Output  | 0.00010333 | 0.00010333 | 0.00010333 |   0.0 |  0.00
Modify  | 0.29867    | 0.29867    | 0.29867    |   0.0 |  0.39
Other   |            | 0.03856    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.695871400551, Press = 0.737110351996709
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -10443.855   -10443.855   -10519.886   -10519.886    294.24981    294.24981    28060.111    28060.111   -1070.9201   -1070.9201 
   39000   -10443.842   -10443.842    -10519.17    -10519.17    291.52691    291.52691    28018.385    28018.385    1342.3177    1342.3177 
Loop time of 77.1705 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.120 ns/day, 21.436 hours/ns, 12.958 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    | 76.778     | 76.778     | 76.778     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052234   | 0.052234   | 0.052234   |   0.0 |  0.07
Output  | 0.00015751 | 0.00015751 | 0.00015751 |   0.0 |  0.00
Modify  | 0.3007     | 0.3007     | 0.3007     |   0.0 |  0.39
Other   |            | 0.03909    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740805561779, Press = 1.20412190695115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -10443.842   -10443.842    -10519.17    -10519.17    291.52691    291.52691    28018.385    28018.385    1342.3177    1342.3177 
   40000   -10446.263   -10446.263   -10520.988   -10520.988    289.19554    289.19554    28047.494    28047.494   -552.37785   -552.37785 
Loop time of 77.5027 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.115 ns/day, 21.529 hours/ns, 12.903 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    | 77.112     | 77.112     | 77.112     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052457   | 0.052457   | 0.052457   |   0.0 |  0.07
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.29885    | 0.29885    | 0.29885    |   0.0 |  0.39
Other   |            | 0.03872    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.798855662196, Press = 2.24987629145968
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -10446.263   -10446.263   -10520.988   -10520.988    289.19554    289.19554    28047.494    28047.494   -552.37785   -552.37785 
   41000   -10444.507   -10444.507   -10519.653   -10519.653    290.82262    290.82262    28089.993    28089.993   -2650.6501   -2650.6501 
Loop time of 69.7193 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.239 ns/day, 19.366 hours/ns, 14.343 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    | 69.365     | 69.365     | 69.365     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047414   | 0.047414   | 0.047414   |   0.0 |  0.07
Output  | 0.0001762  | 0.0001762  | 0.0001762  |   0.0 |  0.00
Modify  | 0.2713     | 0.2713     | 0.2713     |   0.0 |  0.39
Other   |            | 0.03592    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807603097609, Press = -1.21551707897178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -10444.507   -10444.507   -10519.653   -10519.653    290.82262    290.82262    28089.993    28089.993   -2650.6501   -2650.6501 
   42000   -10449.208   -10449.208     -10522.8     -10522.8    284.80879    284.80879    27973.776    27973.776    3307.8433    3307.8433 
Loop time of 64.7109 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.335 ns/day, 17.975 hours/ns, 15.453 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    | 64.382     | 64.382     | 64.382     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043685   | 0.043685   | 0.043685   |   0.0 |  0.07
Output  | 0.00013923 | 0.00013923 | 0.00013923 |   0.0 |  0.00
Modify  | 0.25104    | 0.25104    | 0.25104    |   0.0 |  0.39
Other   |            | 0.0336     |            |       |  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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.757136779646, Press = 0.955023645354391
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -10449.208   -10449.208     -10522.8     -10522.8    284.80879    284.80879    27973.776    27973.776    3307.8433    3307.8433 
   43000   -10443.812   -10443.812    -10518.13    -10518.13    287.61953    287.61953    28046.779    28046.779    -136.6152    -136.6152 
Loop time of 54.9278 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.573 ns/day, 15.258 hours/ns, 18.206 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    | 54.643     | 54.643     | 54.643     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037053   | 0.037053   | 0.037053   |   0.0 |  0.07
Output  | 0.00014681 | 0.00014681 | 0.00014681 |   0.0 |  0.00
Modify  | 0.21695    | 0.21695    | 0.21695    |   0.0 |  0.39
Other   |            | 0.0306     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.759106233341, Press = 2.26935512287721
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -10443.812   -10443.812    -10518.13    -10518.13    287.61953    287.61953    28046.779    28046.779    -136.6152    -136.6152 
   44000   -10445.896   -10445.896   -10520.743   -10520.743    289.66714    289.66714    28062.962    28062.962   -1378.1578   -1378.1578 
Loop time of 65.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.324 ns/day, 18.130 hours/ns, 15.321 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    | 64.936     | 64.936     | 64.936     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043723   | 0.043723   | 0.043723   |   0.0 |  0.07
Output  | 0.0001356  | 0.0001356  | 0.0001356  |   0.0 |  0.00
Modify  | 0.25436    | 0.25436    | 0.25436    |   0.0 |  0.39
Other   |            | 0.03442    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.792148733228, Press = 0.478388293431709
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -10445.896   -10445.896   -10520.743   -10520.743    289.66714    289.66714    28062.962    28062.962   -1378.1578   -1378.1578 
   45000   -10445.678   -10445.678   -10521.094   -10521.094     291.8694     291.8694    28004.341    28004.341    1891.7758    1891.7758 
Loop time of 77.3102 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.475 hours/ns, 12.935 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    | 76.925     | 76.925     | 76.925     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051805   | 0.051805   | 0.051805   |   0.0 |  0.07
Output  | 0.00013931 | 0.00013931 | 0.00013931 |   0.0 |  0.00
Modify  | 0.29537    | 0.29537    | 0.29537    |   0.0 |  0.38
Other   |            | 0.03752    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.822133410568, Press = 0.776745443155338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -10445.678   -10445.678   -10521.094   -10521.094     291.8694     291.8694    28004.341    28004.341    1891.7758    1891.7758 
   46000   -10444.192   -10444.192   -10518.095   -10518.095    286.01069    286.01069    28039.088    28039.088    237.57379    237.57379 
Loop time of 73.1236 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.182 ns/day, 20.312 hours/ns, 13.675 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    | 72.759     | 72.759     | 72.759     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049025   | 0.049025   | 0.049025   |   0.0 |  0.07
Output  | 0.00014556 | 0.00014556 | 0.00014556 |   0.0 |  0.00
Modify  | 0.27975    | 0.27975    | 0.27975    |   0.0 |  0.38
Other   |            | 0.03592    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.812123682962, Press = 3.14001933942606
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -10444.192   -10444.192   -10518.095   -10518.095    286.01069    286.01069    28039.088    28039.088    237.57379    237.57379 
   47000    -10441.21    -10441.21   -10520.278   -10520.278    306.00108    306.00108    28090.654    28090.654   -2665.0617   -2665.0617 
Loop time of 74.3716 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.162 ns/day, 20.659 hours/ns, 13.446 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    | 74.001     | 74.001     | 74.001     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049835   | 0.049835   | 0.049835   |   0.0 |  0.07
Output  | 0.00010869 | 0.00010869 | 0.00010869 |   0.0 |  0.00
Modify  | 0.28453    | 0.28453    | 0.28453    |   0.0 |  0.38
Other   |            | 0.03638    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.887576967045, Press = 0.346942803771937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -10441.21    -10441.21   -10520.278   -10520.278    306.00108    306.00108    28090.654    28090.654   -2665.0617   -2665.0617 
   48000   -10444.771   -10444.771   -10519.559   -10519.559    289.44011    289.44011    28022.752    28022.752    927.27151    927.27151 
Loop time of 66.1815 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.306 ns/day, 18.384 hours/ns, 15.110 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    | 65.846     | 65.846     | 65.846     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044584   | 0.044584   | 0.044584   |   0.0 |  0.07
Output  | 0.00014878 | 0.00014878 | 0.00014878 |   0.0 |  0.00
Modify  | 0.25703    | 0.25703    | 0.25703    |   0.0 |  0.39
Other   |            | 0.03396    |            |       |  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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.918276366045, Press = 0.790127688639252
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -10444.771   -10444.771   -10519.559   -10519.559    289.44011    289.44011    28022.752    28022.752    927.27151    927.27151 
   49000   -10443.506   -10443.506   -10520.676   -10520.676    298.65422    298.65422    28037.727    28037.727    157.55938    157.55938 
Loop time of 71.6923 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.205 ns/day, 19.915 hours/ns, 13.948 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    | 71.33      | 71.33      | 71.33      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048264   | 0.048264   | 0.048264   |   0.0 |  0.07
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.27716    | 0.27716    | 0.27716    |   0.0 |  0.39
Other   |            | 0.03635    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968336539756, Press = 1.52704941180447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -10443.506   -10443.506   -10520.676   -10520.676    298.65422    298.65422    28037.727    28037.727    157.55938    157.55938 
   50000   -10445.495   -10445.495   -10522.117   -10522.117     296.5386     296.5386    28051.003    28051.003   -846.49162   -846.49162 
Loop time of 66.7437 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.295 ns/day, 18.540 hours/ns, 14.983 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    | 66.401     | 66.401     | 66.401     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045112   | 0.045112   | 0.045112   |   0.0 |  0.07
Output  | 0.00014866 | 0.00014866 | 0.00014866 |   0.0 |  0.00
Modify  | 0.26189    | 0.26189    | 0.26189    |   0.0 |  0.39
Other   |            | 0.03549    |            |       |  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:      115992.0 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.957444168215, Press = 1.20672904001141
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -10445.495   -10445.495   -10522.117   -10522.117     296.5386     296.5386    28051.003    28051.003   -846.49162   -846.49162 
   51000   -10444.265   -10444.265   -10519.679   -10519.679    291.85709    291.85709    28040.215    28040.215   -19.505885   -19.505885 
Loop time of 77.2846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.468 hours/ns, 12.939 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    | 76.896     | 76.896     | 76.896     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051924   | 0.051924   | 0.051924   |   0.0 |  0.07
Output  | 0.00014822 | 0.00014822 | 0.00014822 |   0.0 |  0.00
Modify  | 0.29808    | 0.29808    | 0.29808    |   0.0 |  0.39
Other   |            | 0.03861    |            |       |  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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.93251151546, Press = 0.583088238440257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -10444.265   -10444.265   -10519.679   -10519.679    291.85709    291.85709    28040.215    28040.215   -19.505885   -19.505885 
   52000   -10446.759   -10446.759    -10520.11    -10520.11    283.87701    283.87701    28011.426    28011.426    1436.8155    1436.8155 
Loop time of 77.4431 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.512 hours/ns, 12.913 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    | 77.054     | 77.054     | 77.054     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051952   | 0.051952   | 0.051952   |   0.0 |  0.07
Output  | 0.00014792 | 0.00014792 | 0.00014792 |   0.0 |  0.00
Modify  | 0.29835    | 0.29835    | 0.29835    |   0.0 |  0.39
Other   |            | 0.03868    |            |       |  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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915197355917, Press = 1.38343059047158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -10446.759   -10446.759    -10520.11    -10520.11    283.87701    283.87701    28011.426    28011.426    1436.8155    1436.8155 
   53000   -10443.492   -10443.492    -10520.34    -10520.34    297.40963    297.40963    28068.445    28068.445    -1705.805    -1705.805 
Loop time of 50.0521 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.726 ns/day, 13.903 hours/ns, 19.979 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    | 49.792     | 49.792     | 49.792     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03416    | 0.03416    | 0.03416    |   0.0 |  0.07
Output  | 0.00014099 | 0.00014099 | 0.00014099 |   0.0 |  0.00
Modify  | 0.19752    | 0.19752    | 0.19752    |   0.0 |  0.39
Other   |            | 0.02836    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.89939309194, Press = 1.4820932891402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -10443.492   -10443.492    -10520.34    -10520.34    297.40963    297.40963    28068.445    28068.445    -1705.805    -1705.805 
   54000   -10442.834   -10442.834   -10518.906   -10518.906    294.40742    294.40742     28055.59     28055.59   -714.83327   -714.83327 
Loop time of 75.7232 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.141 ns/day, 21.034 hours/ns, 13.206 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    | 75.344     | 75.344     | 75.344     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050887   | 0.050887   | 0.050887   |   0.0 |  0.07
Output  | 0.00014043 | 0.00014043 | 0.00014043 |   0.0 |  0.00
Modify  | 0.29051    | 0.29051    | 0.29051    |   0.0 |  0.38
Other   |            | 0.03732    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.891577489549, Press = -0.512425052371612
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -10442.834   -10442.834   -10518.906   -10518.906    294.40742    294.40742     28055.59     28055.59   -714.83327   -714.83327 
   55000   -10445.063   -10445.063   -10521.424   -10521.424    295.52532    295.52532     27977.92     27977.92    3345.6285    3345.6285 
Loop time of 66.2438 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.304 ns/day, 18.401 hours/ns, 15.096 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    | 65.91      | 65.91      | 65.91      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044578   | 0.044578   | 0.044578   |   0.0 |  0.07
Output  | 0.00015968 | 0.00015968 | 0.00015968 |   0.0 |  0.00
Modify  | 0.2554     | 0.2554     | 0.2554     |   0.0 |  0.39
Other   |            | 0.0337     |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.900157451337, Press = 1.3980073037196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -10445.063   -10445.063   -10521.424   -10521.424    295.52532    295.52532     27977.92     27977.92    3345.6285    3345.6285 
   56000   -10443.472   -10443.472   -10518.463   -10518.463    290.22392    290.22392    28064.668    28064.668   -1237.3566   -1237.3566 
Loop time of 81.2924 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.063 ns/day, 22.581 hours/ns, 12.301 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    | 80.877     | 80.877     | 80.877     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054105   | 0.054105   | 0.054105   |   0.0 |  0.07
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.31931    | 0.31931    | 0.31931    |   0.0 |  0.39
Other   |            | 0.0417     |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897977096568, Press = 1.60184917036872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -10443.472   -10443.472   -10518.463   -10518.463    290.22392    290.22392    28064.668    28064.668   -1237.3566   -1237.3566 
   57000   -10446.485   -10446.485   -10520.769   -10520.769     287.4868     287.4868    28039.019    28039.019   -66.803652   -66.803652 
Loop time of 77.2961 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.471 hours/ns, 12.937 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    | 76.912     | 76.912     | 76.912     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052152   | 0.052152   | 0.052152   |   0.0 |  0.07
Output  | 0.0001405  | 0.0001405  | 0.0001405  |   0.0 |  0.00
Modify  | 0.29474    | 0.29474    | 0.29474    |   0.0 |  0.38
Other   |            | 0.03737    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870241493071, Press = 0.381130262567104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -10446.485   -10446.485   -10520.769   -10520.769     287.4868     287.4868    28039.019    28039.019   -66.803652   -66.803652 
   58000   -10443.929   -10443.929   -10519.414   -10519.414    292.13288    292.13288    28026.812    28026.812    755.30978    755.30978 
Loop time of 69.6402 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.241 ns/day, 19.344 hours/ns, 14.360 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    | 69.288     | 69.288     | 69.288     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047089   | 0.047089   | 0.047089   |   0.0 |  0.07
Output  | 0.00014926 | 0.00014926 | 0.00014926 |   0.0 |  0.00
Modify  | 0.2691     | 0.2691     | 0.2691     |   0.0 |  0.39
Other   |            | 0.03552    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.853297434891, Press = 1.1024556587765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -10443.929   -10443.929   -10519.414   -10519.414    292.13288    292.13288    28026.812    28026.812    755.30978    755.30978 
   59000   -10446.504   -10446.504   -10522.624   -10522.624    294.59152    294.59152    28045.677    28045.677   -505.36535   -505.36535 
Loop time of 66.8176 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.293 ns/day, 18.560 hours/ns, 14.966 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    | 66.479     | 66.479     | 66.479     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045119   | 0.045119   | 0.045119   |   0.0 |  0.07
Output  | 6.4354e-05 | 6.4354e-05 | 6.4354e-05 |   0.0 |  0.00
Modify  | 0.25921    | 0.25921    | 0.25921    |   0.0 |  0.39
Other   |            | 0.03412    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81929376511, Press = 1.28113953188157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -10446.504   -10446.504   -10522.624   -10522.624    294.59152    294.59152    28045.677    28045.677   -505.36535   -505.36535 
   60000   -10441.642   -10441.642   -10519.093   -10519.093    299.74605    299.74605    28065.034    28065.034   -972.34556   -972.34556 
Loop time of 65.2403 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.324 ns/day, 18.122 hours/ns, 15.328 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    | 64.907     | 64.907     | 64.907     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044286   | 0.044286   | 0.044286   |   0.0 |  0.07
Output  | 0.00017006 | 0.00017006 | 0.00017006 |   0.0 |  0.00
Modify  | 0.25461    | 0.25461    | 0.25461    |   0.0 |  0.39
Other   |            | 0.03415    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.844986512944, Press = -0.326476692436986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -10441.642   -10441.642   -10519.093   -10519.093    299.74605    299.74605    28065.034    28065.034   -972.34556   -972.34556 
   61000     -10447.4     -10447.4   -10522.414   -10522.414     290.3099     290.3099    27987.709    27987.709    2689.8154    2689.8154 
Loop time of 65.9747 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.310 ns/day, 18.326 hours/ns, 15.157 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    | 65.638     | 65.638     | 65.638     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044663   | 0.044663   | 0.044663   |   0.0 |  0.07
Output  | 0.00010409 | 0.00010409 | 0.00010409 |   0.0 |  0.00
Modify  | 0.25751    | 0.25751    | 0.25751    |   0.0 |  0.39
Other   |            | 0.03454    |            |       |  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:      115974.0 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845361527053, Press = 0.866026475606257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000     -10447.4     -10447.4   -10522.414   -10522.414     290.3099     290.3099    27987.709    27987.709    2689.8154    2689.8154 
   62000   -10443.603   -10443.603   -10520.219   -10520.219    296.51425    296.51425    28061.744    28061.744   -1240.4931   -1240.4931 
Loop time of 65.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.316 ns/day, 18.238 hours/ns, 15.231 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    | 65.322     | 65.322     | 65.322     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044382   | 0.044382   | 0.044382   |   0.0 |  0.07
Output  | 0.00014844 | 0.00014844 | 0.00014844 |   0.0 |  0.00
Modify  | 0.25566    | 0.25566    | 0.25566    |   0.0 |  0.39
Other   |            | 0.03391    |            |       |  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:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.829309409814, Press = 1.48671860237407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -10443.603   -10443.603   -10520.219   -10520.219    296.51425    296.51425    28061.744    28061.744   -1240.4931   -1240.4931 
   63000   -10446.077   -10446.077    -10521.39    -10521.39    291.46997    291.46997    28054.118    28054.118     -797.668     -797.668 
Loop time of 67.0907 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.288 ns/day, 18.636 hours/ns, 14.905 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    | 66.749     | 66.749     | 66.749     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045473   | 0.045473   | 0.045473   |   0.0 |  0.07
Output  | 0.00010575 | 0.00010575 | 0.00010575 |   0.0 |  0.00
Modify  | 0.261      | 0.261      | 0.261      |   0.0 |  0.39
Other   |            | 0.03477    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.792883767517, Press = 0.267708918389978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -10446.077   -10446.077    -10521.39    -10521.39    291.46997    291.46997    28054.118    28054.118     -797.668     -797.668 
   64000   -10445.362   -10445.362    -10521.11    -10521.11    293.15349    293.15349    28024.884    28024.884    725.22363    725.22363 
Loop time of 70.6761 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.222 ns/day, 19.632 hours/ns, 14.149 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    | 70.32      | 70.32      | 70.32      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047685   | 0.047685   | 0.047685   |   0.0 |  0.07
Output  | 0.0001486  | 0.0001486  | 0.0001486  |   0.0 |  0.00
Modify  | 0.27202    | 0.27202    | 0.27202    |   0.0 |  0.38
Other   |            | 0.03582    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.791916044911, Press = 0.740929744431432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -10445.362   -10445.362    -10521.11    -10521.11    293.15349    293.15349    28024.884    28024.884    725.22363    725.22363 
   65000   -10441.309   -10441.309   -10517.892   -10517.892    296.38442    296.38442    28044.705    28044.705    109.16011    109.16011 
Loop time of 70.3268 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.229 ns/day, 19.535 hours/ns, 14.219 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    | 69.97      | 69.97      | 69.97      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047705   | 0.047705   | 0.047705   |   0.0 |  0.07
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.27309    | 0.27309    | 0.27309    |   0.0 |  0.39
Other   |            | 0.03597    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81242130637, Press = 0.927707376316977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -10441.309   -10441.309   -10517.892   -10517.892    296.38442    296.38442    28044.705    28044.705    109.16011    109.16011 
   66000    -10445.68    -10445.68   -10519.313   -10519.313    284.96562    284.96562    28043.846    28043.846   -207.25172   -207.25172 
Loop time of 76.5669 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.128 ns/day, 21.269 hours/ns, 13.060 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    | 76.183     | 76.183     | 76.183     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05116    | 0.05116    | 0.05116    |   0.0 |  0.07
Output  | 0.00010694 | 0.00010694 | 0.00010694 |   0.0 |  0.00
Modify  | 0.29476    | 0.29476    | 0.29476    |   0.0 |  0.38
Other   |            | 0.0379     |            |       |  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:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.842985203806, Press = 0.683446776739907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -10445.68    -10445.68   -10519.313   -10519.313    284.96562    284.96562    28043.846    28043.846   -207.25172   -207.25172 
   67000   -10441.375   -10441.375   -10518.433   -10518.433    298.22502    298.22502    28039.862    28039.862    322.99187    322.99187 
Loop time of 77.3007 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.472 hours/ns, 12.936 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    | 76.914     | 76.914     | 76.914     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051826   | 0.051826   | 0.051826   |   0.0 |  0.07
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.29705    | 0.29705    | 0.29705    |   0.0 |  0.38
Other   |            | 0.03801    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88517339405, Press = 0.418128164078509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -10441.375   -10441.375   -10518.433   -10518.433    298.22502    298.22502    28039.862    28039.862    322.99187    322.99187 
   68000   -10446.472   -10446.472   -10521.666   -10521.666    291.00816    291.00816     28011.81     28011.81    1454.4647    1454.4647 
Loop time of 77.1868 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.441 hours/ns, 12.956 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    | 76.802     | 76.802     | 76.802     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051927   | 0.051927   | 0.051927   |   0.0 |  0.07
Output  | 9.7808e-05 | 9.7808e-05 | 9.7808e-05 |   0.0 |  0.00
Modify  | 0.29501    | 0.29501    | 0.29501    |   0.0 |  0.38
Other   |            | 0.03732    |            |       |  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:      115968.0 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905272196192, Press = 1.25141268869787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -10446.472   -10446.472   -10521.666   -10521.666    291.00816    291.00816     28011.81     28011.81    1454.4647    1454.4647 
   69000   -10441.783   -10441.783   -10518.182   -10518.182    295.67127    295.67127     28101.74     28101.74   -3007.4545   -3007.4545 
Loop time of 77.2822 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.467 hours/ns, 12.940 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    | 76.898     | 76.898     | 76.898     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051873   | 0.051873   | 0.051873   |   0.0 |  0.07
Output  | 0.0001539  | 0.0001539  | 0.0001539  |   0.0 |  0.00
Modify  | 0.29505    | 0.29505    | 0.29505    |   0.0 |  0.38
Other   |            | 0.0373     |            |       |  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:      115970.0 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941302347368, Press = 1.0366470428683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -10441.783   -10441.783   -10518.182   -10518.182    295.67127    295.67127     28101.74     28101.74   -3007.4545   -3007.4545 
   70000    -10446.31    -10446.31   -10521.457   -10521.457    290.82931    290.82931    28037.803    28037.803    101.88005    101.88005 
Loop time of 77.3416 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.484 hours/ns, 12.930 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    | 76.957     | 76.957     | 76.957     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051953   | 0.051953   | 0.051953   |   0.0 |  0.07
Output  | 0.0001425  | 0.0001425  | 0.0001425  |   0.0 |  0.00
Modify  | 0.29483    | 0.29483    | 0.29483    |   0.0 |  0.38
Other   |            | 0.03723    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.973801439974, Press = -0.339571299444952
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000    -10446.31    -10446.31   -10521.457   -10521.457    290.82931    290.82931    28037.803    28037.803    101.88005    101.88005 
   71000    -10443.53    -10443.53    -10519.88    -10519.88    295.48531    295.48531    28019.162    28019.162    1314.4648    1314.4648 
Loop time of 77.3419 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.117 ns/day, 21.484 hours/ns, 12.930 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    | 76.958     | 76.958     | 76.958     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051761   | 0.051761   | 0.051761   |   0.0 |  0.07
Output  | 9.6451e-05 | 9.6451e-05 | 9.6451e-05 |   0.0 |  0.00
Modify  | 0.29474    | 0.29474    | 0.29474    |   0.0 |  0.38
Other   |            | 0.03727    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.978416825062, Press = 0.932188904016782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -10443.53    -10443.53    -10519.88    -10519.88    295.48531    295.48531    28019.162    28019.162    1314.4648    1314.4648 
   72000   -10447.459   -10447.459   -10522.681   -10522.681    291.11912    291.11912    28056.844    28056.844   -1233.8621   -1233.8621 
Loop time of 77.4066 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.502 hours/ns, 12.919 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    | 77.022     | 77.022     | 77.022     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05191    | 0.05191    | 0.05191    |   0.0 |  0.07
Output  | 0.00014397 | 0.00014397 | 0.00014397 |   0.0 |  0.00
Modify  | 0.29511    | 0.29511    | 0.29511    |   0.0 |  0.38
Other   |            | 0.03743    |            |       |  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:      115972.0 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.982638668526, Press = 0.746486326075998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -10447.459   -10447.459   -10522.681   -10522.681    291.11912    291.11912    28056.844    28056.844   -1233.8621   -1233.8621 
   73000   -10443.236   -10443.236   -10517.816   -10517.816    288.63308    288.63308    28042.884    28042.884    45.626961    45.626961 
Loop time of 77.2971 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.471 hours/ns, 12.937 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    | 76.913     | 76.913     | 76.913     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051715   | 0.051715   | 0.051715   |   0.0 |  0.07
Output  | 0.00015162 | 0.00015162 | 0.00015162 |   0.0 |  0.00
Modify  | 0.29491    | 0.29491    | 0.29491    |   0.0 |  0.38
Other   |            | 0.03737    |            |       |  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:      115994.0 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.965788480213, Press = 0.290824708992161
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -10443.236   -10443.236   -10517.816   -10517.816    288.63308    288.63308    28042.884    28042.884    45.626961    45.626961 
   74000   -10449.637   -10449.637    -10524.59    -10524.59    290.07536    290.07536    28003.961    28003.961    1590.2114    1590.2114 
Loop time of 77.1944 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.443 hours/ns, 12.954 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    | 76.81      | 76.81      | 76.81      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052002   | 0.052002   | 0.052002   |   0.0 |  0.07
Output  | 9.6174e-05 | 9.6174e-05 | 9.6174e-05 |   0.0 |  0.00
Modify  | 0.29458    | 0.29458    | 0.29458    |   0.0 |  0.38
Other   |            | 0.03731    |            |       |  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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.950819457502, Press = 1.05259334563413
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -10449.637   -10449.637    -10524.59    -10524.59    290.07536    290.07536    28003.961    28003.961    1590.2114    1590.2114 
   75000   -10443.973   -10443.973   -10521.469   -10521.469    299.91839    299.91839    28103.174    28103.174   -3364.7755   -3364.7755 
Loop time of 77.3061 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.474 hours/ns, 12.936 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    | 76.922     | 76.922     | 76.922     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051561   | 0.051561   | 0.051561   |   0.0 |  0.07
Output  | 0.00014193 | 0.00014193 | 0.00014193 |   0.0 |  0.00
Modify  | 0.29461    | 0.29461    | 0.29461    |   0.0 |  0.38
Other   |            | 0.03737    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.931627913702, Press = 1.14217502890142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -10443.973   -10443.973   -10521.469   -10521.469    299.91839    299.91839    28103.174    28103.174   -3364.7755   -3364.7755 
   76000   -10450.283   -10450.283   -10523.326   -10523.326     282.6848     282.6848    28038.641    28038.641   -287.77458   -287.77458 
Loop time of 77.4653 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.115 ns/day, 21.518 hours/ns, 12.909 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    | 77.081     | 77.081     | 77.081     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05182    | 0.05182    | 0.05182    |   0.0 |  0.07
Output  | 0.00014107 | 0.00014107 | 0.00014107 |   0.0 |  0.00
Modify  | 0.2945     | 0.2945     | 0.2945     |   0.0 |  0.38
Other   |            | 0.03731    |            |       |  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:      115966.0 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902651786768, Press = -0.249605474675269
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -10450.283   -10450.283   -10523.326   -10523.326     282.6848     282.6848    28038.641    28038.641   -287.77458   -287.77458 
   77000   -10444.803   -10444.803   -10520.245   -10520.245     291.9669     291.9669    28016.305    28016.305    1426.2374    1426.2374 
Loop time of 77.1828 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.440 hours/ns, 12.956 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    | 76.799     | 76.799     | 76.799     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051822   | 0.051822   | 0.051822   |   0.0 |  0.07
Output  | 9.6942e-05 | 9.6942e-05 | 9.6942e-05 |   0.0 |  0.00
Modify  | 0.2948     | 0.2948     | 0.2948     |   0.0 |  0.38
Other   |            | 0.03726    |            |       |  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:      115990.0 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869392613128, Press = 0.753795843346367
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -10444.803   -10444.803   -10520.245   -10520.245     291.9669     291.9669    28016.305    28016.305    1426.2374    1426.2374 
   78000   -10445.852   -10445.852   -10518.353   -10518.353    280.58752    280.58752    28060.014    28060.014   -695.43372   -695.43372 
Loop time of 77.4076 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.116 ns/day, 21.502 hours/ns, 12.919 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    | 77.023     | 77.023     | 77.023     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05178    | 0.05178    | 0.05178    |   0.0 |  0.07
Output  | 0.00014622 | 0.00014622 | 0.00014622 |   0.0 |  0.00
Modify  | 0.29496    | 0.29496    | 0.29496    |   0.0 |  0.38
Other   |            | 0.03744    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865353128072, Press = 0.815512190265944
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -10445.852   -10445.852   -10518.353   -10518.353    280.58752    280.58752    28060.014    28060.014   -695.43372   -695.43372 
   79000   -10441.127   -10441.127   -10519.728   -10519.728    304.19692    304.19692    28051.918    28051.918   -421.00865   -421.00865 
Loop time of 77.3055 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.474 hours/ns, 12.936 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    | 76.921     | 76.921     | 76.921     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051902   | 0.051902   | 0.051902   |   0.0 |  0.07
Output  | 0.0001456  | 0.0001456  | 0.0001456  |   0.0 |  0.00
Modify  | 0.29501    | 0.29501    | 0.29501    |   0.0 |  0.38
Other   |            | 0.03731    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.891139444235, Press = -0.0115103370773622
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -10441.127   -10441.127   -10519.728   -10519.728    304.19692    304.19692    28051.918    28051.918   -421.00865   -421.00865 
   80000   -10446.143   -10446.143   -10520.343   -10520.343    287.16305    287.16305    28009.131    28009.131    1636.1677    1636.1677 
Loop time of 77.2773 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.466 hours/ns, 12.940 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    | 76.894     | 76.894     | 76.894     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051655   | 0.051655   | 0.051655   |   0.0 |  0.07
Output  | 9.6924e-05 | 9.6924e-05 | 9.6924e-05 |   0.0 |  0.00
Modify  | 0.29415    | 0.29415    | 0.29415    |   0.0 |  0.38
Other   |            | 0.03721    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.89954880888, Press = 0.794078544998238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -10446.143   -10446.143   -10520.343   -10520.343    287.16305    287.16305    28009.131    28009.131    1636.1677    1636.1677 
   81000   -10444.319   -10444.319   -10519.727   -10519.727    291.83495    291.83495    28068.843    28068.843   -1472.4046   -1472.4046 
Loop time of 77.2457 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.457 hours/ns, 12.946 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    | 76.862     | 76.862     | 76.862     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051426   | 0.051426   | 0.051426   |   0.0 |  0.07
Output  | 0.00014167 | 0.00014167 | 0.00014167 |   0.0 |  0.00
Modify  | 0.29484    | 0.29484    | 0.29484    |   0.0 |  0.38
Other   |            | 0.03749    |            |       |  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:      115978.0 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902998584135, Press = 0.883373134577865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -10444.319   -10444.319   -10519.727   -10519.727    291.83495    291.83495    28068.843    28068.843   -1472.4046   -1472.4046 
   82000   -10445.553   -10445.553    -10521.64    -10521.64    294.46204    294.46204    28051.691    28051.691   -720.37033   -720.37033 
Loop time of 77.2831 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.468 hours/ns, 12.939 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    | 76.898     | 76.898     | 76.898     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052112   | 0.052112   | 0.052112   |   0.0 |  0.07
Output  | 0.00014214 | 0.00014214 | 0.00014214 |   0.0 |  0.00
Modify  | 0.29563    | 0.29563    | 0.29563    |   0.0 |  0.38
Other   |            | 0.03754    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.918064862102, Press = -0.0475770289097731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -10445.553   -10445.553    -10521.64    -10521.64    294.46204    294.46204    28051.691    28051.691   -720.37033   -720.37033 
   83000   -10447.562   -10447.562   -10522.912   -10522.912    291.61281    291.61281    28002.394    28002.394      1910.09      1910.09 
Loop time of 77.1656 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.120 ns/day, 21.435 hours/ns, 12.959 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    | 76.78      | 76.78      | 76.78      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051833   | 0.051833   | 0.051833   |   0.0 |  0.07
Output  | 0.00010533 | 0.00010533 | 0.00010533 |   0.0 |  0.00
Modify  | 0.29561    | 0.29561    | 0.29561    |   0.0 |  0.38
Other   |            | 0.03754    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930025903991, Press = 0.64537558412009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -10447.562   -10447.562   -10522.912   -10522.912    291.61281    291.61281    28002.394    28002.394      1910.09      1910.09 
   84000   -10443.766   -10443.766   -10519.373   -10519.373    292.60643    292.60643    28072.271    28072.271    -1537.241    -1537.241 
Loop time of 77.2395 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.119 ns/day, 21.455 hours/ns, 12.947 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    | 76.855     | 76.855     | 76.855     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051893   | 0.051893   | 0.051893   |   0.0 |  0.07
Output  | 0.00014416 | 0.00014416 | 0.00014416 |   0.0 |  0.00
Modify  | 0.29487    | 0.29487    | 0.29487    |   0.0 |  0.38
Other   |            | 0.03746    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90770998111, Press = 1.19326464277863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -10443.766   -10443.766   -10519.373   -10519.373    292.60643    292.60643    28072.271    28072.271    -1537.241    -1537.241 
   85000   -10448.238   -10448.238   -10521.642   -10521.642     284.0799     284.0799    28064.692    28064.692   -1449.1672   -1449.1672 
Loop time of 77.2659 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.463 hours/ns, 12.942 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    | 76.882     | 76.882     | 76.882     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051778   | 0.051778   | 0.051778   |   0.0 |  0.07
Output  | 9.7562e-05 | 9.7562e-05 | 9.7562e-05 |   0.0 |  0.00
Modify  | 0.29461    | 0.29461    | 0.29461    |   0.0 |  0.38
Other   |            | 0.0374     |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880460274001, Press = -0.518646213354157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -10448.238   -10448.238   -10521.642   -10521.642     284.0799     284.0799    28064.692    28064.692   -1449.1672   -1449.1672 
   86000   -10446.098   -10446.098   -10518.884   -10518.884    281.68796    281.68796    28006.827    28006.827    1995.9911    1995.9911 
Loop time of 77.4742 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.115 ns/day, 21.521 hours/ns, 12.908 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    | 77.09      | 77.09      | 77.09      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051594   | 0.051594   | 0.051594   |   0.0 |  0.07
Output  | 0.00014214 | 0.00014214 | 0.00014214 |   0.0 |  0.00
Modify  | 0.29525    | 0.29525    | 0.29525    |   0.0 |  0.38
Other   |            | 0.03751    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883509109975, Press = 0.598579795595072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -10446.098   -10446.098   -10518.884   -10518.884    281.68796    281.68796    28006.827    28006.827    1995.9911    1995.9911 
   87000   -10449.165   -10449.165   -10522.606   -10522.606    284.22258    284.22258    28040.786    28040.786   -277.79149   -277.79149 
Loop time of 76.9089 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.123 ns/day, 21.364 hours/ns, 13.002 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    | 76.527     | 76.527     | 76.527     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05151    | 0.05151    | 0.05151    |   0.0 |  0.07
Output  | 0.00014063 | 0.00014063 | 0.00014063 |   0.0 |  0.00
Modify  | 0.2933     | 0.2933     | 0.2933     |   0.0 |  0.38
Other   |            | 0.03732    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868750226345, Press = 0.607084195981437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -10449.165   -10449.165   -10522.606   -10522.606    284.22258    284.22258    28040.786    28040.786   -277.79149   -277.79149 
   88000   -10443.564   -10443.564   -10520.994   -10520.994    299.66002    299.66002    28053.612    28053.612   -649.22069   -649.22069 
Loop time of 77.2736 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.118 ns/day, 21.465 hours/ns, 12.941 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    | 76.89      | 76.89      | 76.89      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051729   | 0.051729   | 0.051729   |   0.0 |  0.07
Output  | 9.5637e-05 | 9.5637e-05 | 9.5637e-05 |   0.0 |  0.00
Modify  | 0.29468    | 0.29468    | 0.29468    |   0.0 |  0.38
Other   |            | 0.03711    |            |       |  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:      115976.0 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856708456895, Press = 0.289547892106643
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -10443.564   -10443.564   -10520.994   -10520.994    299.66002    299.66002    28053.612    28053.612   -649.22069   -649.22069 
   89000   -10447.049   -10447.049    -10523.07    -10523.07    294.20809    294.20809    28021.642    28021.642    994.00808    994.00808 
Loop time of 72.2689 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.196 ns/day, 20.075 hours/ns, 13.837 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    | 71.906     | 71.906     | 71.906     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048582   | 0.048582   | 0.048582   |   0.0 |  0.07
Output  | 0.00014828 | 0.00014828 | 0.00014828 |   0.0 |  0.00
Modify  | 0.278      | 0.278      | 0.278      |   0.0 |  0.38
Other   |            | 0.03612    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845197592655, Press = 0.423704717641353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -10447.049   -10447.049    -10523.07    -10523.07    294.20809    294.20809    28021.642    28021.642    994.00808    994.00808 
   90000   -10439.738   -10439.738   -10516.406   -10516.406    296.71355    296.71355    28053.133    28053.133   -93.987338   -93.987338 
Loop time of 71.6001 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.207 ns/day, 19.889 hours/ns, 13.966 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    | 71.24      | 71.24      | 71.24      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048054   | 0.048054   | 0.048054   |   0.0 |  0.07
Output  | 0.00010371 | 0.00010371 | 0.00010371 |   0.0 |  0.00
Modify  | 0.27573    | 0.27573    | 0.27573    |   0.0 |  0.39
Other   |            | 0.03598    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865069590304, Press = 1.01643936163516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -10439.738   -10439.738   -10516.406   -10516.406    296.71355    296.71355    28053.133    28053.133   -93.987338   -93.987338 
   91000   -10446.164   -10446.164   -10520.339   -10520.339    287.06719    287.06719    28068.404    28068.404   -1509.1314   -1509.1314 
Loop time of 70.6392 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.223 ns/day, 19.622 hours/ns, 14.156 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    | 70.282     | 70.282     | 70.282     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047853   | 0.047853   | 0.047853   |   0.0 |  0.07
Output  | 0.00010454 | 0.00010454 | 0.00010454 |   0.0 |  0.00
Modify  | 0.27312    | 0.27312    | 0.27312    |   0.0 |  0.39
Other   |            | 0.03596    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883870641189, Press = 0.113873362916484
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -10446.164   -10446.164   -10520.339   -10520.339    287.06719    287.06719    28068.404    28068.404   -1509.1314   -1509.1314 
   92000    -10441.33    -10441.33   -10518.982   -10518.982     300.5194     300.5194    28006.152    28006.152    2142.6039    2142.6039 
Loop time of 71.9252 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.201 ns/day, 19.979 hours/ns, 13.903 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    | 71.562     | 71.562     | 71.562     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048582   | 0.048582   | 0.048582   |   0.0 |  0.07
Output  | 0.00014757 | 0.00014757 | 0.00014757 |   0.0 |  0.00
Modify  | 0.27798    | 0.27798    | 0.27798    |   0.0 |  0.39
Other   |            | 0.03619    |            |       |  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:      115980.0 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905737865357, Press = 0.194864816920957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000    -10441.33    -10441.33   -10518.982   -10518.982     300.5194     300.5194    28006.152    28006.152    2142.6039    2142.6039 
   93000   -10445.515   -10445.515   -10520.811   -10520.811    291.40388    291.40388    28043.504    28043.504   -132.98306   -132.98306 
Loop time of 73.7665 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.171 ns/day, 20.491 hours/ns, 13.556 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    | 73.397     | 73.397     | 73.397     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049444   | 0.049444   | 0.049444   |   0.0 |  0.07
Output  | 0.00011919 | 0.00011919 | 0.00011919 |   0.0 |  0.00
Modify  | 0.2834     | 0.2834     | 0.2834     |   0.0 |  0.38
Other   |            | 0.03652    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907261479411, Press = 1.18379610814042
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -10445.515   -10445.515   -10520.811   -10520.811    291.40388    291.40388    28043.504    28043.504   -132.98306   -132.98306 
   94000   -10443.564   -10443.564   -10517.637   -10517.637     286.6702     286.6702    28070.757    28070.757   -1300.1095   -1300.1095 
Loop time of 72.9887 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.184 ns/day, 20.275 hours/ns, 13.701 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    | 72.622     | 72.622     | 72.622     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048947   | 0.048947   | 0.048947   |   0.0 |  0.07
Output  | 0.00014754 | 0.00014754 | 0.00014754 |   0.0 |  0.00
Modify  | 0.28113    | 0.28113    | 0.28113    |   0.0 |  0.39
Other   |            | 0.03643    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888742676311, Press = 0.161188037938194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -10443.564   -10443.564   -10517.637   -10517.637     286.6702     286.6702    28070.757    28070.757   -1300.1095   -1300.1095 
   95000   -10446.315   -10446.315   -10520.694   -10520.694    287.85622    287.85622    28022.372    28022.372    899.51543    899.51543 
Loop time of 71.8278 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.203 ns/day, 19.952 hours/ns, 13.922 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    | 71.466     | 71.466     | 71.466     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048456   | 0.048456   | 0.048456   |   0.0 |  0.07
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.27747    | 0.27747    | 0.27747    |   0.0 |  0.39
Other   |            | 0.03614    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.866755674982, Press = 0.227333823840855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -10446.315   -10446.315   -10520.694   -10520.694    287.85622    287.85622    28022.372    28022.372    899.51543    899.51543 
   96000   -10447.358   -10447.358   -10522.212   -10522.212    289.69102    289.69102    28037.857    28037.857   -72.929398   -72.929398 
Loop time of 72.6767 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.189 ns/day, 20.188 hours/ns, 13.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    | 72.311     | 72.311     | 72.311     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049059   | 0.049059   | 0.049059   |   0.0 |  0.07
Output  | 0.00011344 | 0.00011344 | 0.00011344 |   0.0 |  0.00
Modify  | 0.2801     | 0.2801     | 0.2801     |   0.0 |  0.39
Other   |            | 0.03637    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855197093198, Press = 0.688170951887631
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -10447.358   -10447.358   -10522.212   -10522.212    289.69102    289.69102    28037.857    28037.857   -72.929398   -72.929398 
   97000   -10442.578   -10442.578   -10519.852   -10519.852    299.05926    299.05926    28066.361    28066.361    -1350.497    -1350.497 
Loop time of 73.0399 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.183 ns/day, 20.289 hours/ns, 13.691 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    | 72.673     | 72.673     | 72.673     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049507   | 0.049507   | 0.049507   |   0.0 |  0.07
Output  | 9.1766e-05 | 9.1766e-05 | 9.1766e-05 |   0.0 |  0.00
Modify  | 0.28101    | 0.28101    | 0.28101    |   0.0 |  0.38
Other   |            | 0.03652    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858849693216, Press = 0.249236687461689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -10442.578   -10442.578   -10519.852   -10519.852    299.05926    299.05926    28066.361    28066.361    -1350.497    -1350.497 
   98000   -10446.395   -10446.395   -10519.231   -10519.231     281.8799     281.8799    27998.729    27998.729    2279.8668    2279.8668 
Loop time of 71.8685 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.202 ns/day, 19.963 hours/ns, 13.914 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    | 71.506     | 71.506     | 71.506     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048729   | 0.048729   | 0.048729   |   0.0 |  0.07
Output  | 5.8643e-05 | 5.8643e-05 | 5.8643e-05 |   0.0 |  0.00
Modify  | 0.27711    | 0.27711    | 0.27711    |   0.0 |  0.39
Other   |            | 0.03616    |            |       |  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:      115986.0 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87383011325, Press = -0.0300901827359312
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -10446.395   -10446.395   -10519.231   -10519.231     281.8799     281.8799    27998.729    27998.729    2279.8668    2279.8668 
   99000   -10440.446   -10440.446   -10518.466   -10518.466    301.94406    301.94406    28027.515    28027.515    1046.5629    1046.5629 
Loop time of 72.2123 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.196 ns/day, 20.059 hours/ns, 13.848 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    | 71.849     | 71.849     | 71.849     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048548   | 0.048548   | 0.048548   |   0.0 |  0.07
Output  | 0.00011374 | 0.00011374 | 0.00011374 |   0.0 |  0.00
Modify  | 0.27836    | 0.27836    | 0.27836    |   0.0 |  0.39
Other   |            | 0.03615    |            |       |  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:      115988.0 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897075534186, Press = 1.35779555223282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -10440.446   -10440.446   -10518.466   -10518.466    301.94406    301.94406    28027.515    28027.515    1046.5629    1046.5629 
  100000   -10446.106   -10446.106   -10519.669   -10519.669    284.69905    284.69905    28070.335    28070.335   -1404.5263   -1404.5263 
Loop time of 72.6539 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.189 ns/day, 20.182 hours/ns, 13.764 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    | 72.289     | 72.289     | 72.289     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048812   | 0.048812   | 0.048812   |   0.0 |  0.07
Output  | 0.00017237 | 0.00017237 | 0.00017237 |   0.0 |  0.00
Modify  | 0.27947    | 0.27947    | 0.27947    |   0.0 |  0.38
Other   |            | 0.03634    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910469407022, Press = 0.279980213934842
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -10446.106   -10446.106   -10519.669   -10519.669    284.69905    284.69905    28070.335    28070.335   -1404.5263   -1404.5263 
  101000   -10443.676   -10443.676   -10519.362   -10519.362    292.91198    292.91198    28028.337    28028.337    879.37463    879.37463 
Loop time of 72.0795 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.199 ns/day, 20.022 hours/ns, 13.874 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    | 71.718     | 71.718     | 71.718     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048497   | 0.048497   | 0.048497   |   0.0 |  0.07
Output  | 0.00010455 | 0.00010455 | 0.00010455 |   0.0 |  0.00
Modify  | 0.27719    | 0.27719    | 0.27719    |   0.0 |  0.38
Other   |            | 0.03589    |            |       |  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:      115982.0 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.938456120914, Press = 0.266213925508728
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -10443.676   -10443.676   -10519.362   -10519.362    292.91198    292.91198    28028.337    28028.337    879.37463    879.37463 
  102000   -10446.609   -10446.609   -10521.799   -10521.799    290.99258    290.99258    28043.409    28043.409   -272.20899   -272.20899 
Loop time of 71.0924 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.215 ns/day, 19.748 hours/ns, 14.066 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    | 70.733     | 70.733     | 70.733     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048057   | 0.048057   | 0.048057   |   0.0 |  0.07
Output  | 0.00014769 | 0.00014769 | 0.00014769 |   0.0 |  0.00
Modify  | 0.27519    | 0.27519    | 0.27519    |   0.0 |  0.39
Other   |            | 0.03596    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.960046135727, Press = 0.692492695399375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -10446.609   -10446.609   -10521.799   -10521.799    290.99258    290.99258    28043.409    28043.409   -272.20899   -272.20899 
  103000   -10444.319   -10444.319   -10518.731   -10518.731    287.98365    287.98365    28059.153    28059.153   -897.65883   -897.65883 
Loop time of 71.9413 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.201 ns/day, 19.984 hours/ns, 13.900 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    | 71.58      | 71.58      | 71.58      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048373   | 0.048373   | 0.048373   |   0.0 |  0.07
Output  | 0.00010467 | 0.00010467 | 0.00010467 |   0.0 |  0.00
Modify  | 0.27681    | 0.27681    | 0.27681    |   0.0 |  0.38
Other   |            | 0.03607    |            |       |  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:      115984.0 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
28040.797016996

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0