# 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 4.0419338792562485*${_u_distance}
variable latticeconst_converted equal 4.0419338792562485*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04193387925625
Lattice spacing in x,y,z = 4.0419339 4.0419339 4.0419339
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.419339 40.419339 40.419339)
  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 (40.419339 40.419339 40.419339)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeLee_2010_FeAl__MO_332211522050_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66034.0013456933 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_332211522050_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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13308.492     -13308.492     -13480.701     -13480.701      333.15         333.15         66034.001      66034.001      2785.5335      2785.5335    
      1000  -13104.862     -13104.862     -13282.053     -13282.053      342.78719      342.78719      67943.731      67943.731     -581.15192     -581.15192    
Loop time of 193.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.619 hours/ns, 5.181 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    | 192.11     | 192.11     | 192.11     |   0.0 | 99.52
Neigh   | 0.038641   | 0.038641   | 0.038641   |   0.0 |  0.02
Comm    | 0.112      | 0.112      | 0.112      |   0.0 |  0.06
Output  | 0.00023442 | 0.00023442 | 0.00023442 |   0.0 |  0.00
Modify  | 0.67819    | 0.67819    | 0.67819    |   0.0 |  0.35
Other   |            | 0.09065    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4050 ave        4050 max        4050 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:       213650 ave      213650 max      213650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213650
Ave neighs/atom = 53.4125
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13104.862     -13104.862     -13282.053     -13282.053      342.78719      342.78719      67943.731      67943.731     -581.15192     -581.15192    
      2000  -13129.741     -13129.741     -13297.688     -13297.688      324.90479      324.90479      67790.106      67790.106     -37.164827     -37.164827    
Loop time of 203.306 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.474 hours/ns, 4.919 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    | 202.43     | 202.43     | 202.43     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1126     | 0.1126     | 0.1126     |   0.0 |  0.06
Output  | 0.00022719 | 0.00022719 | 0.00022719 |   0.0 |  0.00
Modify  | 0.67324    | 0.67324    | 0.67324    |   0.0 |  0.33
Other   |            | 0.09198    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4044 ave        4044 max        4044 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:       213458 ave      213458 max      213458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213458
Ave neighs/atom = 53.3645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13129.741     -13129.741     -13297.688     -13297.688      324.90479      324.90479      67790.106      67790.106     -37.164827     -37.164827    
      3000  -13112.684     -13112.684     -13288.635     -13288.635      340.39008      340.39008      67846.237      67846.237      195.90968      195.90968    
Loop time of 202.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.198 hours/ns, 4.943 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    | 201.44     | 201.44     | 201.44     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11177    | 0.11177    | 0.11177    |   0.0 |  0.06
Output  | 0.00022845 | 0.00022845 | 0.00022845 |   0.0 |  0.00
Modify  | 0.67159    | 0.67159    | 0.67159    |   0.0 |  0.33
Other   |            | 0.09286    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4103 ave        4103 max        4103 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:       214062 ave      214062 max      214062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214062
Ave neighs/atom = 53.5155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13112.684     -13112.684     -13288.635     -13288.635      340.39008      340.39008      67846.237      67846.237      195.90968      195.90968    
      4000  -13126.316     -13126.316     -13295.651     -13295.651      327.59007      327.59007      67794.633      67794.633      213.16223      213.16223    
Loop time of 202.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.250 hours/ns, 4.938 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    | 201.62     | 201.62     | 201.62     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11202    | 0.11202    | 0.11202    |   0.0 |  0.06
Output  | 0.00022823 | 0.00022823 | 0.00022823 |   0.0 |  0.00
Modify  | 0.67242    | 0.67242    | 0.67242    |   0.0 |  0.33
Other   |            | 0.09296    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4017 ave        4017 max        4017 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:       213882 ave      213882 max      213882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213882
Ave neighs/atom = 53.4705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13126.316     -13126.316     -13295.651     -13295.651      327.59007      327.59007      67794.633      67794.633      213.16223      213.16223    
      5000  -13116.122     -13116.122     -13287.189     -13287.189      330.94066      330.94066      67861.966      67861.966     -76.988334     -76.988334    
Loop time of 204.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.677 hours/ns, 4.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    | 203.15     | 203.15     | 203.15     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11357    | 0.11357    | 0.11357    |   0.0 |  0.06
Output  | 0.00019886 | 0.00019886 | 0.00019886 |   0.0 |  0.00
Modify  | 0.68257    | 0.68257    | 0.68257    |   0.0 |  0.33
Other   |            | 0.09346    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4063 ave        4063 max        4063 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:       214044 ave      214044 max      214044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214044
Ave neighs/atom = 53.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 336.979033971874, Press = 131.293895430504
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13116.122     -13116.122     -13287.189     -13287.189      330.94066      330.94066      67861.966      67861.966     -76.988334     -76.988334    
      6000  -13123.887     -13123.887     -13294.25      -13294.25       329.57853      329.57853      67790.112      67790.112      246.73528      246.73528    
Loop time of 203.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.423 hours/ns, 4.923 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    | 202.22     | 202.22     | 202.22     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11061    | 0.11061    | 0.11061    |   0.0 |  0.05
Output  | 0.00018818 | 0.00018818 | 0.00018818 |   0.0 |  0.00
Modify  | 0.70169    | 0.70169    | 0.70169    |   0.0 |  0.35
Other   |            | 0.09262    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4019 ave        4019 max        4019 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:       213856 ave      213856 max      213856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213856
Ave neighs/atom = 53.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.060152861541, Press = 11.4504325227206
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13123.887     -13123.887     -13294.25      -13294.25       329.57853      329.57853      67790.112      67790.112      246.73528      246.73528    
      7000  -13118.729     -13118.729     -13290.568     -13290.568      332.4337       332.4337       67864.209      67864.209     -215.24496     -215.24496    
Loop time of 202.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.271 hours/ns, 4.936 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    | 201.68     | 201.68     | 201.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1108     | 0.1108     | 0.1108     |   0.0 |  0.05
Output  | 0.00018794 | 0.00018794 | 0.00018794 |   0.0 |  0.00
Modify  | 0.69534    | 0.69534    | 0.69534    |   0.0 |  0.34
Other   |            | 0.09252    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4006 ave        4006 max        4006 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:       214036 ave      214036 max      214036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214036
Ave neighs/atom = 53.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.427662459228, Press = 9.49090424656089
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13118.729     -13118.729     -13290.568     -13290.568      332.4337       332.4337       67864.209      67864.209     -215.24496     -215.24496    
      8000  -13121.309     -13121.309     -13295.03      -13295.03       336.07357      336.07357      67723.013      67723.013      845.66713      845.66713    
Loop time of 202.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.293 hours/ns, 4.935 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    | 201.75     | 201.75     | 201.75     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11149    | 0.11149    | 0.11149    |   0.0 |  0.06
Output  | 0.0001877  | 0.0001877  | 0.0001877  |   0.0 |  0.00
Modify  | 0.69673    | 0.69673    | 0.69673    |   0.0 |  0.34
Other   |            | 0.09236    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4005 ave        4005 max        4005 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:       213790 ave      213790 max      213790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213790
Ave neighs/atom = 53.4475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.076906514606, Press = -7.38652873503967
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13121.309     -13121.309     -13295.03      -13295.03       336.07357      336.07357      67723.013      67723.013      845.66713      845.66713    
      9000  -13124.97      -13124.97      -13295.264     -13295.264      329.44497      329.44497      67962.915      67962.915     -1448.8277     -1448.8277    
Loop time of 203.556 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.543 hours/ns, 4.913 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    | 202.65     | 202.65     | 202.65     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11297    | 0.11297    | 0.11297    |   0.0 |  0.06
Output  | 0.00018917 | 0.00018917 | 0.00018917 |   0.0 |  0.00
Modify  | 0.69831    | 0.69831    | 0.69831    |   0.0 |  0.34
Other   |            | 0.09188    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4058 ave        4058 max        4058 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:       214120 ave      214120 max      214120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214120
Ave neighs/atom = 53.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.270848455177, Press = 4.54969652027706
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13124.97      -13124.97      -13295.264     -13295.264      329.44497      329.44497      67962.915      67962.915     -1448.8277     -1448.8277    
     10000  -13119.903     -13119.903     -13291.138     -13291.138      331.26558      331.26558      67722.507      67722.507      1299.8834      1299.8834    
Loop time of 202.574 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.271 hours/ns, 4.936 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    | 201.67     | 201.67     | 201.67     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1113     | 0.1113     | 0.1113     |   0.0 |  0.05
Output  | 0.00023113 | 0.00023113 | 0.00023113 |   0.0 |  0.00
Modify  | 0.69819    | 0.69819    | 0.69819    |   0.0 |  0.34
Other   |            | 0.09203    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4045 ave        4045 max        4045 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:       213902 ave      213902 max      213902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213902
Ave neighs/atom = 53.4755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177671569375, Press = 2.6617605363633
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13119.903     -13119.903     -13291.138     -13291.138      331.26558      331.26558      67722.507      67722.507      1299.8834      1299.8834    
     11000  -13118.274     -13118.274     -13292.104     -13292.104      336.28545      336.28545      67872.979      67872.979     -442.72807     -442.72807    
Loop time of 203.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.641 hours/ns, 4.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    | 203        | 203        | 203        |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11392    | 0.11392    | 0.11392    |   0.0 |  0.06
Output  | 0.00018682 | 0.00018682 | 0.00018682 |   0.0 |  0.00
Modify  | 0.70397    | 0.70397    | 0.70397    |   0.0 |  0.35
Other   |            | 0.09165    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4083 ave        4083 max        4083 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:       214012 ave      214012 max      214012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214012
Ave neighs/atom = 53.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.601700619008, Press = -4.89748640752939
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13118.274     -13118.274     -13292.104     -13292.104      336.28545      336.28545      67872.979      67872.979     -442.72807     -442.72807    
     12000  -13120.141     -13120.141     -13292.503     -13292.503      333.44474      333.44474      67821.168      67821.168      193.85732      193.85732    
Loop time of 202.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.285 hours/ns, 4.935 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    | 201.72     | 201.72     | 201.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11141    | 0.11141    | 0.11141    |   0.0 |  0.05
Output  | 0.00018865 | 0.00018865 | 0.00018865 |   0.0 |  0.00
Modify  | 0.69999    | 0.69999    | 0.69999    |   0.0 |  0.35
Other   |            | 0.09239    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4005 ave        4005 max        4005 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:       213938 ave      213938 max      213938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213938
Ave neighs/atom = 53.4845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.62209422445, Press = 1.83402936395206
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13120.141     -13120.141     -13292.503     -13292.503      333.44474      333.44474      67821.168      67821.168      193.85732      193.85732    
     13000  -13112.971     -13112.971     -13290.57      -13290.57       343.57744      343.57744      67886.617      67886.617     -660.15678     -660.15678    
Loop time of 201.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.105 hours/ns, 4.951 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    | 201.08     | 201.08     | 201.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1133     | 0.1133     | 0.1133     |   0.0 |  0.06
Output  | 0.00023172 | 0.00023172 | 0.00023172 |   0.0 |  0.00
Modify  | 0.6946     | 0.6946     | 0.6946     |   0.0 |  0.34
Other   |            | 0.09184    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4072 ave        4072 max        4072 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:       213918 ave      213918 max      213918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213918
Ave neighs/atom = 53.4795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869306085824, Press = -1.64594143293563
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13112.971     -13112.971     -13290.57      -13290.57       343.57744      343.57744      67886.617      67886.617     -660.15678     -660.15678    
     14000  -13121.691     -13121.691     -13292.42      -13292.42       330.28725      330.28725      67787.18       67787.18       409.36643      409.36643    
Loop time of 203.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.422 hours/ns, 4.923 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    | 202.22     | 202.22     | 202.22     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11087    | 0.11087    | 0.11087    |   0.0 |  0.05
Output  | 0.000457   | 0.000457   | 0.000457   |   0.0 |  0.00
Modify  | 0.69768    | 0.69768    | 0.69768    |   0.0 |  0.34
Other   |            | 0.09169    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4012 ave        4012 max        4012 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:       213792 ave      213792 max      213792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213792
Ave neighs/atom = 53.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.823141418855, Press = 4.84857681112658
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13121.691     -13121.691     -13292.42      -13292.42       330.28725      330.28725      67787.18       67787.18       409.36643      409.36643    
     15000  -13114.31      -13114.31      -13288.81      -13288.81       337.58176      337.58176      67788.476      67788.476      502.2878       502.2878     
Loop time of 203.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.432 hours/ns, 4.922 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    | 202.25     | 202.25     | 202.25     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11161    | 0.11161    | 0.11161    |   0.0 |  0.05
Output  | 0.00018634 | 0.00018634 | 0.00018634 |   0.0 |  0.00
Modify  | 0.70198    | 0.70198    | 0.70198    |   0.0 |  0.35
Other   |            | 0.09172    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4043 ave        4043 max        4043 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:       214006 ave      214006 max      214006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214006
Ave neighs/atom = 53.5015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.970621087681, Press = -4.58422090673554
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13114.31      -13114.31      -13288.81      -13288.81       337.58176      337.58176      67788.476      67788.476      502.2878       502.2878     
     16000  -13121.439     -13121.439     -13289.719     -13289.719      325.54872      325.54872      67884.139      67884.139     -313.66594     -313.66594    
Loop time of 202.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.192 hours/ns, 4.943 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    | 201.39     | 201.39     | 201.39     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11435    | 0.11435    | 0.11435    |   0.0 |  0.06
Output  | 0.00018714 | 0.00018714 | 0.00018714 |   0.0 |  0.00
Modify  | 0.69882    | 0.69882    | 0.69882    |   0.0 |  0.35
Other   |            | 0.09252    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4122 ave        4122 max        4122 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:       213810 ave      213810 max      213810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213810
Ave neighs/atom = 53.4525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.939625923594, Press = 0.932837970688608
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13121.439     -13121.439     -13289.719     -13289.719      325.54872      325.54872      67884.139      67884.139     -313.66594     -313.66594    
     17000  -13118.755     -13118.755     -13293.687     -13293.687      338.41765      338.41765      67808.38       67808.38       93.755014      93.755014    
Loop time of 202.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.387 hours/ns, 4.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.09     | 202.09     | 202.09     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11106    | 0.11106    | 0.11106    |   0.0 |  0.05
Output  | 0.00029695 | 0.00029695 | 0.00029695 |   0.0 |  0.00
Modify  | 0.69889    | 0.69889    | 0.69889    |   0.0 |  0.34
Other   |            | 0.09165    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4021 ave        4021 max        4021 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:       213872 ave      213872 max      213872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213872
Ave neighs/atom = 53.468
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.008453508204, Press = 0.764272396327176
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13118.755     -13118.755     -13293.687     -13293.687      338.41765      338.41765      67808.38       67808.38       93.755014      93.755014    
     18000  -13119.698     -13119.698     -13292.817     -13292.817      334.91023      334.91023      67863.387      67863.387     -351.64443     -351.64443    
Loop time of 202.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.145 hours/ns, 4.947 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    | 201.22     | 201.22     | 201.22     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1117     | 0.1117     | 0.1117     |   0.0 |  0.06
Output  | 0.00023568 | 0.00023568 | 0.00023568 |   0.0 |  0.00
Modify  | 0.69436    | 0.69436    | 0.69436    |   0.0 |  0.34
Other   |            | 0.09302    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4040 ave        4040 max        4040 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:       214026 ave      214026 max      214026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214026
Ave neighs/atom = 53.5065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.958456269054, Press = -0.429076584195339
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13119.698     -13119.698     -13292.817     -13292.817      334.91023      334.91023      67863.387      67863.387     -351.64443     -351.64443    
     19000  -13122.699     -13122.699     -13291.042     -13291.042      325.67079      325.67079      67799.977      67799.977      329.70413      329.70413    
Loop time of 203.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.618 hours/ns, 4.906 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    | 202.92     | 202.92     | 202.92     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11257    | 0.11257    | 0.11257    |   0.0 |  0.06
Output  | 0.00018699 | 0.00018699 | 0.00018699 |   0.0 |  0.00
Modify  | 0.70046    | 0.70046    | 0.70046    |   0.0 |  0.34
Other   |            | 0.09208    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4048 ave        4048 max        4048 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:       213972 ave      213972 max      213972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213972
Ave neighs/atom = 53.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90979796798, Press = 1.5172319936706
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13122.699     -13122.699     -13291.042     -13291.042      325.67079      325.67079      67799.977      67799.977      329.70413      329.70413    
     20000  -13118.441     -13118.441     -13292.639     -13292.639      336.99771      336.99771      67817.661      67817.661     -8.9367811     -8.9367811    
Loop time of 202.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.377 hours/ns, 4.927 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    | 202.05     | 202.05     | 202.05     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11056    | 0.11056    | 0.11056    |   0.0 |  0.05
Output  | 0.00018682 | 0.00018682 | 0.00018682 |   0.0 |  0.00
Modify  | 0.70105    | 0.70105    | 0.70105    |   0.0 |  0.35
Other   |            | 0.09235    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4016 ave        4016 max        4016 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:       213940 ave      213940 max      213940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213940
Ave neighs/atom = 53.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.949221216946, Press = -2.42241224902436
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13118.441     -13118.441     -13292.639     -13292.639      336.99771      336.99771      67817.661      67817.661     -8.9367811     -8.9367811    
     21000  -13121.925     -13121.925     -13291.371     -13291.371      327.80467      327.80467      67876.703      67876.703     -577.71906     -577.71906    
Loop time of 202.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.283 hours/ns, 4.935 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    | 201.71     | 201.71     | 201.71     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11314    | 0.11314    | 0.11314    |   0.0 |  0.06
Output  | 0.00018746 | 0.00018746 | 0.00018746 |   0.0 |  0.00
Modify  | 0.70132    | 0.70132    | 0.70132    |   0.0 |  0.35
Other   |            | 0.09319    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4073 ave        4073 max        4073 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:       213978 ave      213978 max      213978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213978
Ave neighs/atom = 53.4945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.908084001652, Press = 1.48453230828619
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13121.925     -13121.925     -13291.371     -13291.371      327.80467      327.80467      67876.703      67876.703     -577.71906     -577.71906    
     22000  -13125.597     -13125.597     -13295.975     -13295.975      329.60791      329.60791      67697.894      67697.894      1316.5863      1316.5863    
Loop time of 202.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.283 hours/ns, 4.935 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    | 201.72     | 201.72     | 201.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11145    | 0.11145    | 0.11145    |   0.0 |  0.06
Output  | 0.00018643 | 0.00018643 | 0.00018643 |   0.0 |  0.00
Modify  | 0.69751    | 0.69751    | 0.69751    |   0.0 |  0.34
Other   |            | 0.09252    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4024 ave        4024 max        4024 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:       213898 ave      213898 max      213898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213898
Ave neighs/atom = 53.4745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.885921987299, Press = 0.476843240579711
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13125.597     -13125.597     -13295.975     -13295.975      329.60791      329.60791      67697.894      67697.894      1316.5863      1316.5863    
     23000  -13119.48      -13119.48      -13289.981     -13289.981      329.84551      329.84551      67935.846      67935.846     -1056.1277     -1056.1277    
Loop time of 202.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.344 hours/ns, 4.930 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    | 201.94     | 201.94     | 201.94     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11143    | 0.11143    | 0.11143    |   0.0 |  0.05
Output  | 0.00018724 | 0.00018724 | 0.00018724 |   0.0 |  0.00
Modify  | 0.69547    | 0.69547    | 0.69547    |   0.0 |  0.34
Other   |            | 0.09249    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4046 ave        4046 max        4046 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:       214172 ave      214172 max      214172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214172
Ave neighs/atom = 53.543
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.769400717858, Press = -1.20041445028991
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13119.48      -13119.48      -13289.981     -13289.981      329.84551      329.84551      67935.846      67935.846     -1056.1277     -1056.1277    
     24000  -13121.114     -13121.114     -13294.223     -13294.223      334.89223      334.89223      67805.451      67805.451      45.247629      45.247629    
Loop time of 202.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.195 hours/ns, 4.943 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    | 201.4      | 201.4      | 201.4      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11262    | 0.11262    | 0.11262    |   0.0 |  0.06
Output  | 0.00023019 | 0.00023019 | 0.00023019 |   0.0 |  0.00
Modify  | 0.69594    | 0.69594    | 0.69594    |   0.0 |  0.34
Other   |            | 0.09298    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4059 ave        4059 max        4059 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:       213824 ave      213824 max      213824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213824
Ave neighs/atom = 53.456
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.728058582709, Press = 1.71839297407349
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13121.114     -13121.114     -13294.223     -13294.223      334.89223      334.89223      67805.451      67805.451      45.247629      45.247629    
     25000  -13115.197     -13115.197     -13291.901     -13291.901      341.84599      341.84599      67844.805      67844.805     -95.18789      -95.18789     
Loop time of 203.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.530 hours/ns, 4.914 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    | 202.6      | 202.6      | 202.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11185    | 0.11185    | 0.11185    |   0.0 |  0.05
Output  | 0.00018706 | 0.00018706 | 0.00018706 |   0.0 |  0.00
Modify  | 0.70186    | 0.70186    | 0.70186    |   0.0 |  0.34
Other   |            | 0.09241    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4028 ave        4028 max        4028 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:       214040 ave      214040 max      214040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214040
Ave neighs/atom = 53.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.78009973975, Press = -0.0203997849027479
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13115.197     -13115.197     -13291.901     -13291.901      341.84599      341.84599      67844.805      67844.805     -95.18789      -95.18789     
     26000  -13121.919     -13121.919     -13293.861     -13293.861      332.63221      332.63221      67794.597      67794.597      368.29071      368.29071    
Loop time of 202.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.365 hours/ns, 4.928 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    | 202.01     | 202.01     | 202.01     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11252    | 0.11252    | 0.11252    |   0.0 |  0.06
Output  | 0.00018471 | 0.00018471 | 0.00018471 |   0.0 |  0.00
Modify  | 0.699      | 0.699      | 0.699      |   0.0 |  0.34
Other   |            | 0.09292    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4102 ave        4102 max        4102 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:       213906 ave      213906 max      213906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213906
Ave neighs/atom = 53.4765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.745931874368, Press = -0.194648895035609
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13121.919     -13121.919     -13293.861     -13293.861      332.63221      332.63221      67794.597      67794.597      368.29071      368.29071    
     27000  -13122.193     -13122.193     -13293.15      -13293.15       330.72872      330.72872      67870.554      67870.554     -506.31551     -506.31551    
Loop time of 202.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.384 hours/ns, 4.927 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    | 202.08     | 202.08     | 202.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11146    | 0.11146    | 0.11146    |   0.0 |  0.05
Output  | 0.00027213 | 0.00027213 | 0.00027213 |   0.0 |  0.00
Modify  | 0.69994    | 0.69994    | 0.69994    |   0.0 |  0.34
Other   |            | 0.092      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4058 ave        4058 max        4058 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:       213980 ave      213980 max      213980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213980
Ave neighs/atom = 53.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.773867846232, Press = -0.0351783805750201
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13122.193     -13122.193     -13293.15      -13293.15       330.72872      330.72872      67870.554      67870.554     -506.31551     -506.31551    
     28000  -13119.477     -13119.477     -13289.449     -13289.449      328.82127      328.82127      67753.846      67753.846      1177.7773      1177.7773    
Loop time of 202.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.162 hours/ns, 4.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.28     | 201.28     | 201.28     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11178    | 0.11178    | 0.11178    |   0.0 |  0.06
Output  | 0.00018843 | 0.00018843 | 0.00018843 |   0.0 |  0.00
Modify  | 0.69652    | 0.69652    | 0.69652    |   0.0 |  0.34
Other   |            | 0.09139    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4052 ave        4052 max        4052 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:       213948 ave      213948 max      213948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213948
Ave neighs/atom = 53.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.797567991238, Press = 2.55041061833095
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13119.477     -13119.477     -13289.449     -13289.449      328.82127      328.82127      67753.846      67753.846      1177.7773      1177.7773    
     29000  -13126.216     -13126.216     -13298.72      -13298.72       333.72063      333.72063      67767.234      67767.234      242.47947      242.47947    
Loop time of 203.391 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.497 hours/ns, 4.917 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    | 202.48     | 202.48     | 202.48     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11257    | 0.11257    | 0.11257    |   0.0 |  0.06
Output  | 0.00018751 | 0.00018751 | 0.00018751 |   0.0 |  0.00
Modify  | 0.7026     | 0.7026     | 0.7026     |   0.0 |  0.35
Other   |            | 0.09294    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4074 ave        4074 max        4074 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:       214042 ave      214042 max      214042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214042
Ave neighs/atom = 53.5105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.763370075779, Press = -1.14096382166038
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13126.216     -13126.216     -13298.72      -13298.72       333.72063      333.72063      67767.234      67767.234      242.47947      242.47947    
     30000  -13119.113     -13119.113     -13292.888     -13292.888      336.1786       336.1786       67910.515      67910.515     -1004.5939     -1004.5939    
Loop time of 202.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.318 hours/ns, 4.932 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    | 201.85     | 201.85     | 201.85     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11044    | 0.11044    | 0.11044    |   0.0 |  0.05
Output  | 0.00022848 | 0.00022848 | 0.00022848 |   0.0 |  0.00
Modify  | 0.69475    | 0.69475    | 0.69475    |   0.0 |  0.34
Other   |            | 0.09236    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4033 ave        4033 max        4033 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:       214198 ave      214198 max      214198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214198
Ave neighs/atom = 53.5495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.685583426065, Press = 0.702590766597012
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13119.113     -13119.113     -13292.888     -13292.888      336.1786       336.1786       67910.515      67910.515     -1004.5939     -1004.5939    
     31000  -13120.475     -13120.475     -13291.711     -13291.711      331.26705      331.26705      67741.77       67741.77       970.26324      970.26324    
Loop time of 202.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.269 hours/ns, 4.937 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    | 201.67     | 201.67     | 201.67     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11227    | 0.11227    | 0.11227    |   0.0 |  0.06
Output  | 0.00024782 | 0.00024782 | 0.00024782 |   0.0 |  0.00
Modify  | 0.6965     | 0.6965     | 0.6965     |   0.0 |  0.34
Other   |            | 0.09228    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4073 ave        4073 max        4073 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:       213846 ave      213846 max      213846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213846
Ave neighs/atom = 53.4615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.679252099157, Press = 0.541421159952084
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13120.475     -13120.475     -13291.711     -13291.711      331.26705      331.26705      67741.77       67741.77       970.26324      970.26324    
     32000  -13118.011     -13118.011     -13291.171     -13291.171      334.99105      334.99105      67847.892      67847.892     -376.30898     -376.30898    
Loop time of 202.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.287 hours/ns, 4.935 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    | 201.73     | 201.73     | 201.73     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11183    | 0.11183    | 0.11183    |   0.0 |  0.06
Output  | 0.00018766 | 0.00018766 | 0.00018766 |   0.0 |  0.00
Modify  | 0.69578    | 0.69578    | 0.69578    |   0.0 |  0.34
Other   |            | 0.0922     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4082 ave        4082 max        4082 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:       213980 ave      213980 max      213980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213980
Ave neighs/atom = 53.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.688227186017, Press = -0.0850564200047566
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13118.011     -13118.011     -13291.171     -13291.171      334.99105      334.99105      67847.892      67847.892     -376.30898     -376.30898    
     33000  -13117.211     -13117.211     -13291.348     -13291.348      336.87943      336.87943      67847.662      67847.662     -233.77836     -233.77836    
Loop time of 202.379 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.216 hours/ns, 4.941 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    | 201.48     | 201.48     | 201.48     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11162    | 0.11162    | 0.11162    |   0.0 |  0.06
Output  | 0.00018682 | 0.00018682 | 0.00018682 |   0.0 |  0.00
Modify  | 0.69652    | 0.69652    | 0.69652    |   0.0 |  0.34
Other   |            | 0.09215    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4043 ave        4043 max        4043 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:       213808 ave      213808 max      213808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213808
Ave neighs/atom = 53.452
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.749277945058, Press = 0.786713480054047
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13117.211     -13117.211     -13291.348     -13291.348      336.87943      336.87943      67847.662      67847.662     -233.77836     -233.77836    
     34000  -13117.416     -13117.416     -13289.506     -13289.506      332.91929      332.91929      67819.537      67819.537      215.64354      215.64354    
Loop time of 202.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.156 hours/ns, 4.947 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    | 201.26     | 201.26     | 201.26     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11127    | 0.11127    | 0.11127    |   0.0 |  0.06
Output  | 0.00018478 | 0.00018478 | 0.00018478 |   0.0 |  0.00
Modify  | 0.69321    | 0.69321    | 0.69321    |   0.0 |  0.34
Other   |            | 0.0917     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4074 ave        4074 max        4074 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:       213850 ave      213850 max      213850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213850
Ave neighs/atom = 53.4625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.69768953121, Press = -0.134805788913705
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13117.416     -13117.416     -13289.506     -13289.506      332.91929      332.91929      67819.537      67819.537      215.64354      215.64354    
     35000  -13121.964     -13121.964     -13294.288     -13294.288      333.37359      333.37359      67866.36       67866.36      -580.20121     -580.20121    
Loop time of 201.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.922 hours/ns, 4.967 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    | 200.43     | 200.43     | 200.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1103     | 0.1103     | 0.1103     |   0.0 |  0.05
Output  | 0.00018731 | 0.00018731 | 0.00018731 |   0.0 |  0.00
Modify  | 0.68818    | 0.68818    | 0.68818    |   0.0 |  0.34
Other   |            | 0.09136    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4012 ave        4012 max        4012 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:       213898 ave      213898 max      213898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213898
Ave neighs/atom = 53.4745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.682157526379, Press = 0.309734218319444
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13121.964     -13121.964     -13294.288     -13294.288      333.37359      333.37359      67866.36       67866.36      -580.20121     -580.20121    
     36000  -13117.314     -13117.314     -13290.989     -13290.989      335.98591      335.98591      67722.235      67722.235      1307.1748      1307.1748    
Loop time of 202.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.321 hours/ns, 4.932 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    | 201.85     | 201.85     | 201.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11203    | 0.11203    | 0.11203    |   0.0 |  0.06
Output  | 0.00018686 | 0.00018686 | 0.00018686 |   0.0 |  0.00
Modify  | 0.6978     | 0.6978     | 0.6978     |   0.0 |  0.34
Other   |            | 0.09286    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4046 ave        4046 max        4046 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:       213884 ave      213884 max      213884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213884
Ave neighs/atom = 53.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.664128207255, Press = 1.18712850078376
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13117.314     -13117.314     -13290.989     -13290.989      335.98591      335.98591      67722.235      67722.235      1307.1748      1307.1748    
     37000  -13124.219     -13124.219     -13294.568     -13294.568      329.55167      329.55167      67840.192      67840.192     -210.24561     -210.24561    
Loop time of 202.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.285 hours/ns, 4.935 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    | 201.72     | 201.72     | 201.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11188    | 0.11188    | 0.11188    |   0.0 |  0.06
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.69699    | 0.69699    | 0.69699    |   0.0 |  0.34
Other   |            | 0.09336    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4060 ave        4060 max        4060 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:       214004 ave      214004 max      214004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214004
Ave neighs/atom = 53.501
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.578406595449, Press = -1.10933168932849
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13124.219     -13124.219     -13294.568     -13294.568      329.55167      329.55167      67840.192      67840.192     -210.24561     -210.24561    
     38000  -13119.853     -13119.853     -13290.208     -13290.208      329.56298      329.56298      67850.135      67850.135     -158.38181     -158.38181    
Loop time of 202.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.221 hours/ns, 4.941 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    | 201.5      | 201.5      | 201.5      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11118    | 0.11118    | 0.11118    |   0.0 |  0.05
Output  | 0.0001865  | 0.0001865  | 0.0001865  |   0.0 |  0.00
Modify  | 0.69692    | 0.69692    | 0.69692    |   0.0 |  0.34
Other   |            | 0.09201    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4058 ave        4058 max        4058 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:       213968 ave      213968 max      213968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213968
Ave neighs/atom = 53.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.556099154885, Press = 1.22784942041985
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13119.853     -13119.853     -13290.208     -13290.208      329.56298      329.56298      67850.135      67850.135     -158.38181     -158.38181    
     39000  -13124.682     -13124.682     -13294.462     -13294.462      328.45158      328.45158      67791.174      67791.174      221.05079      221.05079    
Loop time of 201.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.006 hours/ns, 4.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.72     | 200.72     | 200.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1113     | 0.1113     | 0.1113     |   0.0 |  0.06
Output  | 0.00033803 | 0.00033803 | 0.00033803 |   0.0 |  0.00
Modify  | 0.69345    | 0.69345    | 0.69345    |   0.0 |  0.34
Other   |            | 0.093      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4078 ave        4078 max        4078 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:       213854 ave      213854 max      213854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213854
Ave neighs/atom = 53.4635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.495600954328, Press = 0.0916755101056839
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13124.682     -13124.682     -13294.462     -13294.462      328.45158      328.45158      67791.174      67791.174      221.05079      221.05079    
     40000  -13120.631     -13120.631     -13292.476     -13292.476      332.44567      332.44567      67827.446      67827.446      35.427053      35.427053    
Loop time of 202.08 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.133 hours/ns, 4.949 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    | 201.18     | 201.18     | 201.18     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1117     | 0.1117     | 0.1117     |   0.0 |  0.06
Output  | 0.00019525 | 0.00019525 | 0.00019525 |   0.0 |  0.00
Modify  | 0.69403    | 0.69403    | 0.69403    |   0.0 |  0.34
Other   |            | 0.09198    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4044 ave        4044 max        4044 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:       214108 ave      214108 max      214108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214108
Ave neighs/atom = 53.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.443773328531, Press = 0.44248639323872
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13120.631     -13120.631     -13292.476     -13292.476      332.44567      332.44567      67827.446      67827.446      35.427053      35.427053    
     41000  -13123.003     -13123.003     -13292.481     -13292.481      327.8667       327.8667       67776.279      67776.279      517.50664      517.50664    
Loop time of 203.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.419 hours/ns, 4.923 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    | 202.2      | 202.2      | 202.2      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11302    | 0.11302    | 0.11302    |   0.0 |  0.06
Output  | 0.00018728 | 0.00018728 | 0.00018728 |   0.0 |  0.00
Modify  | 0.69935    | 0.69935    | 0.69935    |   0.0 |  0.34
Other   |            | 0.09247    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4075 ave        4075 max        4075 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:       213942 ave      213942 max      213942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213942
Ave neighs/atom = 53.4855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.426160097343, Press = 0.347227930216427
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13123.003     -13123.003     -13292.481     -13292.481      327.8667       327.8667       67776.279      67776.279      517.50664      517.50664    
     42000  -13117.549     -13117.549     -13291.58      -13291.58       336.674        336.674        67881.492      67881.492     -183.51301     -183.51301    
Loop time of 202.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.387 hours/ns, 4.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.09     | 202.09     | 202.09     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11207    | 0.11207    | 0.11207    |   0.0 |  0.06
Output  | 0.00023507 | 0.00023507 | 0.00023507 |   0.0 |  0.00
Modify  | 0.69627    | 0.69627    | 0.69627    |   0.0 |  0.34
Other   |            | 0.09217    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4073 ave        4073 max        4073 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:       214030 ave      214030 max      214030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214030
Ave neighs/atom = 53.5075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.366790218678, Press = 0.227559046870805
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13117.549     -13117.549     -13291.58      -13291.58       336.674        336.674        67881.492      67881.492     -183.51301     -183.51301    
     43000  -13119.656     -13119.656     -13294.235     -13294.235      337.73409      337.73409      67710.134      67710.134      990.59447      990.59447    
Loop time of 203.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.439 hours/ns, 4.922 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    | 202.27     | 202.27     | 202.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11113    | 0.11113    | 0.11113    |   0.0 |  0.05
Output  | 0.00018602 | 0.00018602 | 0.00018602 |   0.0 |  0.00
Modify  | 0.70407    | 0.70407    | 0.70407    |   0.0 |  0.35
Other   |            | 0.09255    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4076 ave        4076 max        4076 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:       213850 ave      213850 max      213850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213850
Ave neighs/atom = 53.4625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.340855951034, Press = 1.04952150749242
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13119.656     -13119.656     -13294.235     -13294.235      337.73409      337.73409      67710.134      67710.134      990.59447      990.59447    
     44000  -13115.86      -13115.86      -13289.97      -13289.97       336.82653      336.82653      67927.519      67927.519     -916.38266     -916.38266    
Loop time of 203.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.423 hours/ns, 4.923 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    | 202.21     | 202.21     | 202.21     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11237    | 0.11237    | 0.11237    |   0.0 |  0.06
Output  | 0.00018638 | 0.00018638 | 0.00018638 |   0.0 |  0.00
Modify  | 0.7027     | 0.7027     | 0.7027     |   0.0 |  0.35
Other   |            | 0.09359    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4072 ave        4072 max        4072 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:       214136 ave      214136 max      214136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214136
Ave neighs/atom = 53.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.315701741891, Press = -0.870678365471591
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13115.86      -13115.86      -13289.97      -13289.97       336.82653      336.82653      67927.519      67927.519     -916.38266     -916.38266    
     45000  -13120.874     -13120.874     -13293.084     -13293.084      333.15151      333.15151      67791.206      67791.206      301.9553       301.9553     
Loop time of 203.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.464 hours/ns, 4.920 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    | 202.32     | 202.32     | 202.32     |   0.0 | 99.53
Neigh   | 0.038369   | 0.038369   | 0.038369   |   0.0 |  0.02
Comm    | 0.11626    | 0.11626    | 0.11626    |   0.0 |  0.06
Output  | 0.00018738 | 0.00018738 | 0.00018738 |   0.0 |  0.00
Modify  | 0.69922    | 0.69922    | 0.69922    |   0.0 |  0.34
Other   |            | 0.09341    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4078 ave        4078 max        4078 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:       214086 ave      214086 max      214086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214086
Ave neighs/atom = 53.5215
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.327495118776, Press = 0.755196589931851
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13120.874     -13120.874     -13293.084     -13293.084      333.15151      333.15151      67791.206      67791.206      301.9553       301.9553     
     46000  -13123.257     -13123.257     -13293.693     -13293.693      329.72037      329.72037      67813.724      67813.724      92.491413      92.491413    
Loop time of 202.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.206 hours/ns, 4.942 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    | 201.45     | 201.45     | 201.45     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11029    | 0.11029    | 0.11029    |   0.0 |  0.05
Output  | 0.00018721 | 0.00018721 | 0.00018721 |   0.0 |  0.00
Modify  | 0.69283    | 0.69283    | 0.69283    |   0.0 |  0.34
Other   |            | 0.09183    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4040 ave        4040 max        4040 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:       213954 ave      213954 max      213954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213954
Ave neighs/atom = 53.4885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.322225375797, Press = 0.389551307752061
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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13123.257     -13123.257     -13293.693     -13293.693      329.72037      329.72037      67813.724      67813.724      92.491413      92.491413    
     47000  -13124.233     -13124.233     -13292.722     -13292.722      325.95497      325.95497      67782.896      67782.896      404.80228      404.80228    
Loop time of 201.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.887 hours/ns, 4.970 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    | 200.3      | 200.3      | 200.3      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11085    | 0.11085    | 0.11085    |   0.0 |  0.06
Output  | 0.00023015 | 0.00023015 | 0.00023015 |   0.0 |  0.00
Modify  | 0.69097    | 0.69097    | 0.69097    |   0.0 |  0.34
Other   |            | 0.0928     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4063 ave        4063 max        4063 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:       213970 ave      213970 max      213970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0