# 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.613315634429455*${_u_distance}
variable latticeconst_converted equal 3.613315634429455*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331563442945
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_MirazDhariwalMeng_2020_CuNTi__MO_122936827583_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13987.791     -13987.791     -14160         -14160          333.15         333.15         47175.629      47175.629      3899.0518      3899.0518    
      1000  -13798.557     -13798.557     -13976.153     -13976.153      343.57211      343.57211      47945.158      47945.158      1371.6235      1371.6235    
Loop time of 501.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.353 hours/ns, 1.993 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    | 500.72     | 500.72     | 500.72     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15048    | 0.15048    | 0.15048    |   0.0 |  0.03
Output  | 0.00023766 | 0.00023766 | 0.00023766 |   0.0 |  0.00
Modify  | 0.70068    | 0.70068    | 0.70068    |   0.0 |  0.14
Other   |            | 0.09939    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13798.557     -13798.557     -13976.153     -13976.153      343.57211      343.57211      47945.158      47945.158      1371.6235      1371.6235    
      2000  -13814.94      -13814.94      -13986.425     -13986.425      331.74912      331.74912      47952.985      47952.985      22.195347      22.195347    
Loop time of 528.647 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 146.846 hours/ns, 1.892 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    | 527.66     | 527.66     | 527.66     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1531     | 0.1531     | 0.1531     |   0.0 |  0.03
Output  | 0.00024188 | 0.00024188 | 0.00024188 |   0.0 |  0.00
Modify  | 0.73242    | 0.73242    | 0.73242    |   0.0 |  0.14
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528842 ave      528842 max      528842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528842
Ave neighs/atom = 132.2105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13814.94      -13814.94      -13986.425     -13986.425      331.74912      331.74912      47952.985      47952.985      22.195347      22.195347    
      3000  -13807.917     -13807.917     -13984.298     -13984.298      341.22066      341.22066      48003.289      48003.289     -910.70506     -910.70506    
Loop time of 530.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.290 hours/ns, 1.886 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    | 529.26     | 529.26     | 529.26     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15379    | 0.15379    | 0.15379    |   0.0 |  0.03
Output  | 0.00022784 | 0.00022784 | 0.00022784 |   0.0 |  0.00
Modify  | 0.73158    | 0.73158    | 0.73158    |   0.0 |  0.14
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529424 ave      529424 max      529424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529424
Ave neighs/atom = 132.356
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13807.917     -13807.917     -13984.298     -13984.298      341.22066      341.22066      48003.289      48003.289     -910.70506     -910.70506    
      4000  -13812.744     -13812.744     -13985.964     -13985.964      335.10673      335.10673      47965.585      47965.585     -255.92549     -255.92549    
Loop time of 533.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.228 hours/ns, 1.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 532.62     | 532.62     | 532.62     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15644    | 0.15644    | 0.15644    |   0.0 |  0.03
Output  | 0.00022968 | 0.00022968 | 0.00022968 |   0.0 |  0.00
Modify  | 0.74596    | 0.74596    | 0.74596    |   0.0 |  0.14
Other   |            | 0.1034     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528670 ave      528670 max      528670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528670
Ave neighs/atom = 132.1675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13812.744     -13812.744     -13985.964     -13985.964      335.10673      335.10673      47965.585      47965.585     -255.92549     -255.92549    
      5000  -13810.752     -13810.752     -13984.024     -13984.024      335.20615      335.20615      47948.423      47948.423      393.83286      393.83286    
Loop time of 533.978 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.327 hours/ns, 1.873 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    | 532.98     | 532.98     | 532.98     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15573    | 0.15573    | 0.15573    |   0.0 |  0.03
Output  | 0.00019845 | 0.00019845 | 0.00019845 |   0.0 |  0.00
Modify  | 0.74201    | 0.74201    | 0.74201    |   0.0 |  0.14
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5848 ave        5848 max        5848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528946 ave      528946 max      528946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528946
Ave neighs/atom = 132.2365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 335.991640802223, Press = 428.406762806839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13810.752     -13810.752     -13984.024     -13984.024      335.20615      335.20615      47948.423      47948.423      393.83286      393.83286    
      6000  -13811.265     -13811.265     -13983.629     -13983.629      333.45038      333.45038      47898.175      47898.175      1640.9921      1640.9921    
Loop time of 533.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.068 hours/ns, 1.876 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    | 532.02     | 532.02     | 532.02     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15483    | 0.15483    | 0.15483    |   0.0 |  0.03
Output  | 0.00019232 | 0.00019232 | 0.00019232 |   0.0 |  0.00
Modify  | 0.76848    | 0.76848    | 0.76848    |   0.0 |  0.14
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529022 ave      529022 max      529022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529022
Ave neighs/atom = 132.2555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.520492037927, Press = 36.2076472757457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13811.265     -13811.265     -13983.629     -13983.629      333.45038      333.45038      47898.175      47898.175      1640.9921      1640.9921    
      7000  -13810.409     -13810.409     -13984.802     -13984.802      337.37508      337.37508      47893.968      47893.968      1705.8138      1705.8138    
Loop time of 527.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.164 ns/day, 146.595 hours/ns, 1.895 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    | 526.73     | 526.73     | 526.73     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15294    | 0.15294    | 0.15294    |   0.0 |  0.03
Output  | 0.00019754 | 0.00019754 | 0.00019754 |   0.0 |  0.00
Modify  | 0.75373    | 0.75373    | 0.75373    |   0.0 |  0.14
Other   |            | 0.1013     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529128 ave      529128 max      529128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529128
Ave neighs/atom = 132.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.206891390828, Press = -4.74403445639169
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13810.409     -13810.409     -13984.802     -13984.802      337.37508      337.37508      47893.968      47893.968      1705.8138      1705.8138    
      8000  -13810.594     -13810.594     -13982.087     -13982.087      331.76362      331.76362      47948.365      47948.365      561.6054       561.6054     
Loop time of 526.283 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.164 ns/day, 146.190 hours/ns, 1.900 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    | 525.28     | 525.28     | 525.28     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15316    | 0.15316    | 0.15316    |   0.0 |  0.03
Output  | 0.00020235 | 0.00020235 | 0.00020235 |   0.0 |  0.00
Modify  | 0.75326    | 0.75326    | 0.75326    |   0.0 |  0.14
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529372 ave      529372 max      529372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529372
Ave neighs/atom = 132.343
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.834748254437, Press = -12.04704284346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13810.594     -13810.594     -13982.087     -13982.087      331.76362      331.76362      47948.365      47948.365      561.6054       561.6054     
      9000  -13814.964     -13814.964     -13981.605     -13981.605      322.37829      322.37829      47989.245      47989.245     -569.37796     -569.37796    
Loop time of 523.31 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.165 ns/day, 145.364 hours/ns, 1.911 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    | 522.31     | 522.31     | 522.31     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15314    | 0.15314    | 0.15314    |   0.0 |  0.03
Output  | 0.00024589 | 0.00024589 | 0.00024589 |   0.0 |  0.00
Modify  | 0.7473     | 0.7473     | 0.7473     |   0.0 |  0.14
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529004 ave      529004 max      529004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529004
Ave neighs/atom = 132.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.804258787476, Press = -3.11436225511866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13814.964     -13814.964     -13981.605     -13981.605      322.37829      322.37829      47989.245      47989.245     -569.37796     -569.37796    
     10000  -13806.708     -13806.708     -13982.475     -13982.475      340.03288      340.03288      47994.885      47994.885     -613.17485     -613.17485    
Loop time of 524.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.165 ns/day, 145.792 hours/ns, 1.905 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    | 523.84     | 523.84     | 523.84     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15509    | 0.15509    | 0.15509    |   0.0 |  0.03
Output  | 0.00019283 | 0.00019283 | 0.00019283 |   0.0 |  0.00
Modify  | 0.75094    | 0.75094    | 0.75094    |   0.0 |  0.14
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5849 ave        5849 max        5849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528452 ave      528452 max      528452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528452
Ave neighs/atom = 132.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.319245335619, Press = 4.74107238230042
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13806.708     -13806.708     -13982.475     -13982.475      340.03288      340.03288      47994.885      47994.885     -613.17485     -613.17485    
     11000  -13812.072     -13812.072     -13983.395     -13983.395      331.43569      331.43569      47981.238      47981.238     -481.30786     -481.30786    
Loop time of 519.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.166 ns/day, 144.295 hours/ns, 1.925 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    | 518.47     | 518.47     | 518.47     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15141    | 0.15141    | 0.15141    |   0.0 |  0.03
Output  | 0.00019196 | 0.00019196 | 0.00019196 |   0.0 |  0.00
Modify  | 0.74013    | 0.74013    | 0.74013    |   0.0 |  0.14
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528648 ave      528648 max      528648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528648
Ave neighs/atom = 132.162
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4547720595, Press = 2.56588656171642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13812.072     -13812.072     -13983.395     -13983.395      331.43569      331.43569      47981.238      47981.238     -481.30786     -481.30786    
     12000  -13812.49      -13812.49      -13985.221     -13985.221      334.16077      334.16077      47972.833      47972.833     -390.39418     -390.39418    
Loop time of 531.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.753 hours/ns, 1.880 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    | 530.89     | 530.89     | 530.89     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15486    | 0.15486    | 0.15486    |   0.0 |  0.03
Output  | 0.00018919 | 0.00018919 | 0.00018919 |   0.0 |  0.00
Modify  | 0.76681    | 0.76681    | 0.76681    |   0.0 |  0.14
Other   |            | 0.1023     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528844 ave      528844 max      528844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528844
Ave neighs/atom = 132.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.617324116795, Press = 2.73573868785613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13812.49      -13812.49      -13985.221     -13985.221      334.16077      334.16077      47972.833      47972.833     -390.39418     -390.39418    
     13000  -13809.277     -13809.277     -13983.35      -13983.35       336.7569       336.7569       47997.516      47997.516     -773.78592     -773.78592    
Loop time of 536.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 149.021 hours/ns, 1.864 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    | 535.43     | 535.43     | 535.43     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15697    | 0.15697    | 0.15697    |   0.0 |  0.03
Output  | 0.000328   | 0.000328   | 0.000328   |   0.0 |  0.00
Modify  | 0.78097    | 0.78097    | 0.78097    |   0.0 |  0.15
Other   |            | 0.1035     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528874 ave      528874 max      528874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528874
Ave neighs/atom = 132.2185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.537336369643, Press = 5.01592000743374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13809.277     -13809.277     -13983.35      -13983.35       336.7569       336.7569       47997.516      47997.516     -773.78592     -773.78592    
     14000  -13817.185     -13817.185     -13988.026     -13988.026      330.50423      330.50423      47937.744      47937.744      210.87741      210.87741    
Loop time of 535.205 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 148.668 hours/ns, 1.868 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    | 534.17     | 534.17     | 534.17     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15625    | 0.15625    | 0.15625    |   0.0 |  0.03
Output  | 0.00051168 | 0.00051168 | 0.00051168 |   0.0 |  0.00
Modify  | 0.77287    | 0.77287    | 0.77287    |   0.0 |  0.14
Other   |            | 0.103      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528696 ave      528696 max      528696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528696
Ave neighs/atom = 132.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.305522007766, Press = 7.39945342886984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13817.185     -13817.185     -13988.026     -13988.026      330.50423      330.50423      47937.744      47937.744      210.87741      210.87741    
     15000  -13811.18      -13811.18      -13982.846     -13982.846      332.0999       332.0999       47920.523      47920.523      1140.617       1140.617     
Loop time of 534.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.363 hours/ns, 1.872 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    | 533.08     | 533.08     | 533.08     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15608    | 0.15608    | 0.15608    |   0.0 |  0.03
Output  | 0.00028997 | 0.00028997 | 0.00028997 |   0.0 |  0.00
Modify  | 0.77088    | 0.77088    | 0.77088    |   0.0 |  0.14
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528980 ave      528980 max      528980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528980
Ave neighs/atom = 132.245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.338105111398, Press = 4.54569353621357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13811.18      -13811.18      -13982.846     -13982.846      332.0999       332.0999       47920.523      47920.523      1140.617       1140.617     
     16000  -13806.839     -13806.839     -13984.26      -13984.26       343.23229      343.23229      47903.293      47903.293      1670.4447      1670.4447    
Loop time of 535.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 148.623 hours/ns, 1.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 534.01     | 534.01     | 534.01     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15535    | 0.15535    | 0.15535    |   0.0 |  0.03
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.77644    | 0.77644    | 0.77644    |   0.0 |  0.15
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528898 ave      528898 max      528898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528898
Ave neighs/atom = 132.2245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.39666976366, Press = 2.16357558338088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13806.839     -13806.839     -13984.26      -13984.26       343.23229      343.23229      47903.293      47903.293      1670.4447      1670.4447    
     17000  -13814.347     -13814.347     -13985.48      -13985.48       331.06834      331.06834      47922.414      47922.414      912.88941      912.88941    
Loop time of 536.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 149.029 hours/ns, 1.864 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    | 535.48     | 535.48     | 535.48     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15596    | 0.15596    | 0.15596    |   0.0 |  0.03
Output  | 0.00023549 | 0.00023549 | 0.00023549 |   0.0 |  0.00
Modify  | 0.77062    | 0.77062    | 0.77062    |   0.0 |  0.14
Other   |            | 0.1021     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529940 ave      529940 max      529940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529940
Ave neighs/atom = 132.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.357510474691, Press = -3.34078071078738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13814.347     -13814.347     -13985.48      -13985.48       331.06834      331.06834      47922.414      47922.414      912.88941      912.88941    
     18000  -13810.554     -13810.554     -13981.758     -13981.758      331.20722      331.20722      48007.769      48007.769     -953.33613     -953.33613    
Loop time of 527.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.164 ns/day, 146.574 hours/ns, 1.895 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    | 526.64     | 526.64     | 526.64     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15514    | 0.15514    | 0.15514    |   0.0 |  0.03
Output  | 0.00023145 | 0.00023145 | 0.00023145 |   0.0 |  0.00
Modify  | 0.76436    | 0.76436    | 0.76436    |   0.0 |  0.14
Other   |            | 0.1025     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529216 ave      529216 max      529216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529216
Ave neighs/atom = 132.304
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.287496007135, Press = -4.27751759923467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13810.554     -13810.554     -13981.758     -13981.758      331.20722      331.20722      48007.769      48007.769     -953.33613     -953.33613    
     19000  -13811.098     -13811.098     -13981.774     -13981.774      330.18417      330.18417      48036.102      48036.102     -1661.3322     -1661.3322    
Loop time of 526.139 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.164 ns/day, 146.150 hours/ns, 1.901 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    | 525.12     | 525.12     | 525.12     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15456    | 0.15456    | 0.15456    |   0.0 |  0.03
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.76113    | 0.76113    | 0.76113    |   0.0 |  0.14
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528592 ave      528592 max      528592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528592
Ave neighs/atom = 132.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.18381948423, Press = 1.08634358045703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13811.098     -13811.098     -13981.774     -13981.774      330.18417      330.18417      48036.102      48036.102     -1661.3322     -1661.3322    
     20000  -13810.852     -13810.852     -13982.381     -13982.381      331.8344       331.8344       47983.085      47983.085     -357.95441     -357.95441    
Loop time of 527.661 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.164 ns/day, 146.572 hours/ns, 1.895 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    | 526.65     | 526.65     | 526.65     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15394    | 0.15394    | 0.15394    |   0.0 |  0.03
Output  | 0.00023195 | 0.00023195 | 0.00023195 |   0.0 |  0.00
Modify  | 0.75634    | 0.75634    | 0.75634    |   0.0 |  0.14
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5848 ave        5848 max        5848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528318 ave      528318 max      528318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528318
Ave neighs/atom = 132.0795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.256618798143, Press = 2.25055960261609
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13810.852     -13810.852     -13982.381     -13982.381      331.8344       331.8344       47983.085      47983.085     -357.95441     -357.95441    
     21000  -13812.787     -13812.787     -13983.942     -13983.942      331.11139      331.11139      47956.712      47956.712      96.767878      96.767878    
Loop time of 535.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 148.673 hours/ns, 1.868 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    | 534.19     | 534.19     | 534.19     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15552    | 0.15552    | 0.15552    |   0.0 |  0.03
Output  | 0.00019184 | 0.00019184 | 0.00019184 |   0.0 |  0.00
Modify  | 0.77423    | 0.77423    | 0.77423    |   0.0 |  0.14
Other   |            | 0.1034     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528826 ave      528826 max      528826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528826
Ave neighs/atom = 132.2065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.170440223632, Press = 2.89439316829596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13812.787     -13812.787     -13983.942     -13983.942      331.11139      331.11139      47956.712      47956.712      96.767878      96.767878    
     22000  -13811.255     -13811.255     -13982.246     -13982.246      330.79444      330.79444      47928.645      47928.645      964.00439      964.00439    
Loop time of 528.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 146.833 hours/ns, 1.892 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    | 527.58     | 527.58     | 527.58     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.03
Output  | 0.00019045 | 0.00019045 | 0.00019045 |   0.0 |  0.00
Modify  | 0.75904    | 0.75904    | 0.75904    |   0.0 |  0.14
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528824 ave      528824 max      528824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528824
Ave neighs/atom = 132.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.178170553811, Press = 1.16565451498719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13811.255     -13811.255     -13982.246     -13982.246      330.79444      330.79444      47928.645      47928.645      964.00439      964.00439    
     23000  -13814.394     -13814.394     -13984.42      -13984.42       328.92741      328.92741      47887.988      47887.988      1772.7133      1772.7133    
Loop time of 531.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.615 hours/ns, 1.882 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    | 530.38     | 530.38     | 530.38     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15613    | 0.15613    | 0.15613    |   0.0 |  0.03
Output  | 0.0001965  | 0.0001965  | 0.0001965  |   0.0 |  0.00
Modify  | 0.77214    | 0.77214    | 0.77214    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528788 ave      528788 max      528788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528788
Ave neighs/atom = 132.197
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.071015403739, Press = -0.31499619503366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13814.394     -13814.394     -13984.42      -13984.42       328.92741      328.92741      47887.988      47887.988      1772.7133      1772.7133    
     24000  -13808.211     -13808.211     -13982.312     -13982.312      336.81105      336.81105      47952.35       47952.35       495.60607      495.60607    
Loop time of 529.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.198 hours/ns, 1.887 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    | 528.89     | 528.89     | 528.89     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15445    | 0.15445    | 0.15445    |   0.0 |  0.03
Output  | 0.00019224 | 0.00019224 | 0.00019224 |   0.0 |  0.00
Modify  | 0.7639     | 0.7639     | 0.7639     |   0.0 |  0.14
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529062 ave      529062 max      529062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529062
Ave neighs/atom = 132.2655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.079105438484, Press = -1.73122979192529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13808.211     -13808.211     -13982.312     -13982.312      336.81105      336.81105      47952.35       47952.35       495.60607      495.60607    
     25000  -13814.223     -13814.223     -13983.802     -13983.802      328.06249      328.06249      47988.134      47988.134     -692.8205      -692.8205     
Loop time of 531.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.766 hours/ns, 1.880 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    | 530.93     | 530.93     | 530.93     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15363    | 0.15363    | 0.15363    |   0.0 |  0.03
Output  | 0.00031581 | 0.00031581 | 0.00031581 |   0.0 |  0.00
Modify  | 0.7663     | 0.7663     | 0.7663     |   0.0 |  0.14
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528784 ave      528784 max      528784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528784
Ave neighs/atom = 132.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.097457271743, Press = -1.37899541117303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13814.223     -13814.223     -13983.802     -13983.802      328.06249      328.06249      47988.134      47988.134     -692.8205      -692.8205     
     26000  -13808.185     -13808.185     -13982.2       -13982.2        336.64472      336.64472      48012.986      48012.986     -1089.0069     -1089.0069    
Loop time of 529.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.168 hours/ns, 1.887 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    | 528.79     | 528.79     | 528.79     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15321    | 0.15321    | 0.15321    |   0.0 |  0.03
Output  | 0.00020019 | 0.00020019 | 0.00020019 |   0.0 |  0.00
Modify  | 0.76187    | 0.76187    | 0.76187    |   0.0 |  0.14
Other   |            | 0.1013     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5847 ave        5847 max        5847 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528580 ave      528580 max      528580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528580
Ave neighs/atom = 132.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.184110736213, Press = 0.72196106154972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13808.185     -13808.185     -13982.2       -13982.2        336.64472      336.64472      48012.986      48012.986     -1089.0069     -1089.0069    
     27000  -13811.96      -13811.96      -13982.509     -13982.509      329.93867      329.93867      47968.254      47968.254     -86.786518     -86.786518    
Loop time of 531.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.750 hours/ns, 1.880 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    | 530.87     | 530.87     | 530.87     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15387    | 0.15387    | 0.15387    |   0.0 |  0.03
Output  | 0.0001937  | 0.0001937  | 0.0001937  |   0.0 |  0.00
Modify  | 0.77021    | 0.77021    | 0.77021    |   0.0 |  0.14
Other   |            | 0.103      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528330 ave      528330 max      528330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528330
Ave neighs/atom = 132.0825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.245805358782, Press = 1.45031644662118
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13811.96      -13811.96      -13982.509     -13982.509      329.93867      329.93867      47968.254      47968.254     -86.786518     -86.786518    
     28000  -13811.195     -13811.195     -13983.527     -13983.527      333.38692      333.38692      47968.414      47968.414     -55.373488     -55.373488    
Loop time of 531.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.716 hours/ns, 1.880 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    | 530.76     | 530.76     | 530.76     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15364    | 0.15364    | 0.15364    |   0.0 |  0.03
Output  | 0.00019544 | 0.00019544 | 0.00019544 |   0.0 |  0.00
Modify  | 0.76496    | 0.76496    | 0.76496    |   0.0 |  0.14
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528572 ave      528572 max      528572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528572
Ave neighs/atom = 132.143
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.341407444549, Press = 1.27359408186679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13811.195     -13811.195     -13983.527     -13983.527      333.38692      333.38692      47968.414      47968.414     -55.373488     -55.373488    
     29000  -13807.692     -13807.692     -13981.118     -13981.118      335.5039       335.5039       47975.996      47975.996      7.7755339      7.7755339    
Loop time of 531.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.724 hours/ns, 1.880 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    | 530.78     | 530.78     | 530.78     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1546     | 0.1546     | 0.1546     |   0.0 |  0.03
Output  | 0.00019266 | 0.00019266 | 0.00019266 |   0.0 |  0.00
Modify  | 0.76948    | 0.76948    | 0.76948    |   0.0 |  0.14
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5849 ave        5849 max        5849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528926 ave      528926 max      528926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528926
Ave neighs/atom = 132.2315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.368922156711, Press = 1.64760721270829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13807.692     -13807.692     -13981.118     -13981.118      335.5039       335.5039       47975.996      47975.996      7.7755339      7.7755339    
     30000  -13810.074     -13810.074     -13982.394     -13982.394      333.36448      333.36448      47907.399      47907.399      1569.5005      1569.5005    
Loop time of 533.733 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.259 hours/ns, 1.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 532.72     | 532.72     | 532.72     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15432    | 0.15432    | 0.15432    |   0.0 |  0.03
Output  | 0.00023808 | 0.00023808 | 0.00023808 |   0.0 |  0.00
Modify  | 0.76208    | 0.76208    | 0.76208    |   0.0 |  0.14
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528688 ave      528688 max      528688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528688
Ave neighs/atom = 132.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.44978793014, Press = 3.15265430624693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13810.074     -13810.074     -13982.394     -13982.394      333.36448      333.36448      47907.399      47907.399      1569.5005      1569.5005    
     31000  -13813.235     -13813.235     -13985.333     -13985.333      332.93469      332.93469      47872.918      47872.918      2137.6413      2137.6413    
Loop time of 531.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.547 hours/ns, 1.883 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    | 530.15     | 530.15     | 530.15     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.03
Output  | 0.00019683 | 0.00019683 | 0.00019683 |   0.0 |  0.00
Modify  | 0.76636    | 0.76636    | 0.76636    |   0.0 |  0.14
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529052 ave      529052 max      529052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529052
Ave neighs/atom = 132.263
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.456147486877, Press = 0.3401021707705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13813.235     -13813.235     -13985.333     -13985.333      332.93469      332.93469      47872.918      47872.918      2137.6413      2137.6413    
     32000  -13809.611     -13809.611     -13981.997     -13981.997      333.49202      333.49202      47941.362      47941.362      784.86058      784.86058    
Loop time of 532.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.852 hours/ns, 1.879 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    | 531.24     | 531.24     | 531.24     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15324    | 0.15324    | 0.15324    |   0.0 |  0.03
Output  | 0.00019139 | 0.00019139 | 0.00019139 |   0.0 |  0.00
Modify  | 0.76707    | 0.76707    | 0.76707    |   0.0 |  0.14
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529748 ave      529748 max      529748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529748
Ave neighs/atom = 132.437
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.400342172354, Press = -0.890549873334935
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13809.611     -13809.611     -13981.997     -13981.997      333.49202      333.49202      47941.362      47941.362      784.86058      784.86058    
     33000  -13807.68      -13807.68      -13981.045     -13981.045      335.38625      335.38625      47985.316      47985.316     -256.21599     -256.21599    
Loop time of 531.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.163 ns/day, 147.645 hours/ns, 1.881 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    | 530.5      | 530.5      | 530.5      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15457    | 0.15457    | 0.15457    |   0.0 |  0.03
Output  | 0.00019023 | 0.00019023 | 0.00019023 |   0.0 |  0.00
Modify  | 0.76986    | 0.76986    | 0.76986    |   0.0 |  0.14
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529088 ave      529088 max      529088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529088
Ave neighs/atom = 132.272
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.350092314248, Press = 0.0265913690784083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13807.68      -13807.68      -13981.045     -13981.045      335.38625      335.38625      47985.316      47985.316     -256.21599     -256.21599    
     34000  -13811.141     -13811.141     -13983.867     -13983.867      334.15113      334.15113      47990.515      47990.515     -659.68831     -659.68831    
Loop time of 535.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.161 ns/day, 148.659 hours/ns, 1.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 534.14     | 534.14     | 534.14     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15513    | 0.15513    | 0.15513    |   0.0 |  0.03
Output  | 0.00024528 | 0.00024528 | 0.00024528 |   0.0 |  0.00
Modify  | 0.77197    | 0.77197    | 0.77197    |   0.0 |  0.14
Other   |            | 0.1031     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5849 ave        5849 max        5849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528398 ave      528398 max      528398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528398
Ave neighs/atom = 132.0995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.350709551893, Press = 0.190189409670838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13811.141     -13811.141     -13983.867     -13983.867      334.15113      334.15113      47990.515      47990.515     -659.68831     -659.68831    
     35000  -13809.932     -13809.932     -13981.541     -13981.541      331.98971      331.98971      48006.91       48006.91      -885.05119     -885.05119    
Loop time of 534.168 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.380 hours/ns, 1.872 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    | 533.13     | 533.13     | 533.13     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15419    | 0.15419    | 0.15419    |   0.0 |  0.03
Output  | 0.00019199 | 0.00019199 | 0.00019199 |   0.0 |  0.00
Modify  | 0.77622    | 0.77622    | 0.77622    |   0.0 |  0.15
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528760 ave      528760 max      528760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528760
Ave neighs/atom = 132.19
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.394330724034, Press = 0.70271879408729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13809.932     -13809.932     -13981.541     -13981.541      331.98971      331.98971      48006.91       48006.91      -885.05119     -885.05119    
     36000  -13815.086     -13815.086     -13984.154     -13984.154      327.07443      327.07443      47983.147      47983.147     -642.57811     -642.57811    
Loop time of 525.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.165 ns/day, 145.881 hours/ns, 1.904 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    | 524.17     | 524.17     | 524.17     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15243    | 0.15243    | 0.15243    |   0.0 |  0.03
Output  | 0.00018778 | 0.00018778 | 0.00018778 |   0.0 |  0.00
Modify  | 0.74805    | 0.74805    | 0.74805    |   0.0 |  0.14
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528274 ave      528274 max      528274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528274
Ave neighs/atom = 132.0685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.376630582822, Press = 2.63375567636267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13815.086     -13815.086     -13984.154     -13984.154      327.07443      327.07443      47983.147      47983.147     -642.57811     -642.57811    
     37000  -13810.633     -13810.633     -13983.583     -13983.583      334.58247      334.58247      47914.225      47914.225      1277.7496      1277.7496    
Loop time of 533.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.057 hours/ns, 1.876 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    | 531.98     | 531.98     | 531.98     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15602    | 0.15602    | 0.15602    |   0.0 |  0.03
Output  | 0.00019191 | 0.00019191 | 0.00019191 |   0.0 |  0.00
Modify  | 0.76891    | 0.76891    | 0.76891    |   0.0 |  0.14
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528766 ave      528766 max      528766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528766
Ave neighs/atom = 132.1915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.372829306244, Press = 2.96673043346825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13810.633     -13810.633     -13983.583     -13983.583      334.58247      334.58247      47914.225      47914.225      1277.7496      1277.7496    
     38000  -13815.855     -13815.855     -13984.233     -13984.233      325.73842      325.73842      47903.556      47903.556      1340.8078      1340.8078    
Loop time of 532.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 147.878 hours/ns, 1.878 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    | 531.34     | 531.34     | 531.34     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15356    | 0.15356    | 0.15356    |   0.0 |  0.03
Output  | 0.00024074 | 0.00024074 | 0.00024074 |   0.0 |  0.00
Modify  | 0.76174    | 0.76174    | 0.76174    |   0.0 |  0.14
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529312 ave      529312 max      529312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529312
Ave neighs/atom = 132.328
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.292449425022, Press = 1.02343176973814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13815.855     -13815.855     -13984.233     -13984.233      325.73842      325.73842      47903.556      47903.556      1340.8078      1340.8078    
     39000  -13809.248     -13809.248     -13982.757     -13982.757      335.66613      335.66613      47948.397      47948.397      525.36078      525.36078    
Loop time of 533.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.162 ns/day, 148.248 hours/ns, 1.874 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 532.67     | 532.67     | 532.67     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15312    | 0.15312    | 0.15312    |   0.0 |  0.03
Output  | 0.00018751 | 0.00018751 | 0.00018751 |   0.0 |  0.00
Modify  | 0.76712    | 0.76712    | 0.76712    |   0.0 |  0.14
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529146 ave      529146 max      529146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0