# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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  -13349.845     -13349.845     -13480.701     -13480.701      253.15         253.15         66034.001      66034.001      2116.6391      2116.6391    
      1000  -13197.786     -13197.786     -13337.087     -13337.087      269.48778      269.48778      67589.584      67589.584     -886.141       -886.141      
Loop time of 185.104 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.418 hours/ns, 5.402 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.23     | 184.23     | 184.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10937    | 0.10937    | 0.10937    |   0.0 |  0.06
Output  | 0.00024125 | 0.00024125 | 0.00024125 |   0.0 |  0.00
Modify  | 0.66889    | 0.66889    | 0.66889    |   0.0 |  0.36
Other   |            | 0.09249    |            |       |  0.05

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

Total # of neighbors = 216000
Ave neighs/atom = 54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13197.786     -13197.786     -13337.087     -13337.087      269.48778      269.48778      67589.584      67589.584     -886.141       -886.141      
      2000  -13215.986     -13215.986     -13342.454     -13342.454      244.66078      244.66078      67442.905      67442.905      528.1425       528.1425     
Loop time of 195.6 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.333 hours/ns, 5.112 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    | 194.74     | 194.74     | 194.74     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10914    | 0.10914    | 0.10914    |   0.0 |  0.06
Output  | 0.00023106 | 0.00023106 | 0.00023106 |   0.0 |  0.00
Modify  | 0.65929    | 0.65929    | 0.65929    |   0.0 |  0.34
Other   |            | 0.09323    |            |       |  0.05

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

Total # of neighbors = 215050
Ave neighs/atom = 53.7625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13215.986     -13215.986     -13342.454     -13342.454      244.66078      244.66078      67442.905      67442.905      528.1425       528.1425     
      3000  -13203.808     -13203.808     -13335.822     -13335.822      255.39026      255.39026      67517.472      67517.472      239.7579       239.7579     
Loop time of 197.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.994 hours/ns, 5.051 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    | 197.1      | 197.1      | 197.1      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11154    | 0.11154    | 0.11154    |   0.0 |  0.06
Output  | 0.0002294  | 0.0002294  | 0.0002294  |   0.0 |  0.00
Modify  | 0.67387    | 0.67387    | 0.67387    |   0.0 |  0.34
Other   |            | 0.09452    |            |       |  0.05

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

Total # of neighbors = 215190
Ave neighs/atom = 53.7975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13203.808     -13203.808     -13335.822     -13335.822      255.39026      255.39026      67517.472      67517.472      239.7579       239.7579     
      4000  -13213.177     -13213.177     -13340.068     -13340.068      245.47911      245.47911      67513.46       67513.46      -160.90413     -160.90413    
Loop time of 196.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.643 hours/ns, 5.083 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    | 195.84     | 195.84     | 195.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11129    | 0.11129    | 0.11129    |   0.0 |  0.06
Output  | 0.00024116 | 0.00024116 | 0.00024116 |   0.0 |  0.00
Modify  | 0.67026    | 0.67026    | 0.67026    |   0.0 |  0.34
Other   |            | 0.0937     |            |       |  0.05

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

Total # of neighbors = 215108
Ave neighs/atom = 53.777
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13213.177     -13213.177     -13340.068     -13340.068      245.47911      245.47911      67513.46       67513.46      -160.90413     -160.90413    
      5000  -13206.992     -13206.992     -13340.358     -13340.358      258.00504      258.00504      67423.502      67423.502      867.48816      867.48816    
Loop time of 198.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.193 hours/ns, 5.033 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    | 197.81     | 197.81     | 197.81     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11132    | 0.11132    | 0.11132    |   0.0 |  0.06
Output  | 0.00018859 | 0.00018859 | 0.00018859 |   0.0 |  0.00
Modify  | 0.68003    | 0.68003    | 0.68003    |   0.0 |  0.34
Other   |            | 0.09434    |            |       |  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:       215144 ave      215144 max      215144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215144
Ave neighs/atom = 53.786
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.748206864017, Press = -31.4441522849593
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  -13206.992     -13206.992     -13340.358     -13340.358      258.00504      258.00504      67423.502      67423.502      867.48816      867.48816    
      6000  -13209.654     -13209.654     -13341.683     -13341.683      255.41942      255.41942      67526.754      67526.754     -530.56948     -530.56948    
Loop time of 198.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.181 hours/ns, 5.034 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    | 197.74     | 197.74     | 197.74     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1119     | 0.1119     | 0.1119     |   0.0 |  0.06
Output  | 0.00020582 | 0.00020582 | 0.00020582 |   0.0 |  0.00
Modify  | 0.70144    | 0.70144    | 0.70144    |   0.0 |  0.35
Other   |            | 0.09421    |            |       |  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:       215170 ave      215170 max      215170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215170
Ave neighs/atom = 53.7925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.669395132674, Press = 20.9459281862147
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13209.654     -13209.654     -13341.683     -13341.683      255.41942      255.41942      67526.754      67526.754     -530.56948     -530.56948    
      7000  -13209.724     -13209.724     -13340.451     -13340.451      252.90065      252.90065      67553.934      67553.934     -633.47177     -633.47177    
Loop time of 197.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.987 hours/ns, 5.052 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    | 197.06     | 197.06     | 197.06     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10901    | 0.10901    | 0.10901    |   0.0 |  0.06
Output  | 0.00022933 | 0.00022933 | 0.00022933 |   0.0 |  0.00
Modify  | 0.6916     | 0.6916     | 0.6916     |   0.0 |  0.35
Other   |            | 0.09364    |            |       |  0.05

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

Total # of neighbors = 215184
Ave neighs/atom = 53.796
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.227905547543, Press = -11.0606295133191
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  -13209.724     -13209.724     -13340.451     -13340.451      252.90065      252.90065      67553.934      67553.934     -633.47177     -633.47177    
      8000  -13205.966     -13205.966     -13339.997     -13339.997      259.29224      259.29224      67476.143      67476.143      400.75988      400.75988    
Loop time of 197.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.878 hours/ns, 5.062 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    | 196.65     | 196.65     | 196.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11196    | 0.11196    | 0.11196    |   0.0 |  0.06
Output  | 0.00018748 | 0.00018748 | 0.00018748 |   0.0 |  0.00
Modify  | 0.70151    | 0.70151    | 0.70151    |   0.0 |  0.36
Other   |            | 0.09367    |            |       |  0.05

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

Total # of neighbors = 215122
Ave neighs/atom = 53.7805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.023725260153, Press = -4.57230409826407
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  -13205.966     -13205.966     -13339.997     -13339.997      259.29224      259.29224      67476.143      67476.143      400.75988      400.75988    
      9000  -13209.55      -13209.55      -13340.131     -13340.131      252.61727      252.61727      67476.602      67476.602      141.118        141.118      
Loop time of 197.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.847 hours/ns, 5.065 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.55     | 196.55     | 196.55     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11181    | 0.11181    | 0.11181    |   0.0 |  0.06
Output  | 0.00018672 | 0.00018672 | 0.00018672 |   0.0 |  0.00
Modify  | 0.69153    | 0.69153    | 0.69153    |   0.0 |  0.35
Other   |            | 0.09341    |            |       |  0.05

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

Total # of neighbors = 215152
Ave neighs/atom = 53.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.476304863181, Press = -0.212233438782592
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13209.55      -13209.55      -13340.131     -13340.131      252.61727      252.61727      67476.602      67476.602      141.118        141.118      
     10000  -13204.787     -13204.787     -13336.597     -13336.597      254.99445      254.99445      67600.546      67600.546     -967.17178     -967.17178    
Loop time of 197.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.974 hours/ns, 5.053 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    | 197        | 197        | 197        |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11101    | 0.11101    | 0.11101    |   0.0 |  0.06
Output  | 0.00018504 | 0.00018504 | 0.00018504 |   0.0 |  0.00
Modify  | 0.69882    | 0.69882    | 0.69882    |   0.0 |  0.35
Other   |            | 0.09363    |            |       |  0.05

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

Total # of neighbors = 215106
Ave neighs/atom = 53.7765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.516412035696, Press = -3.56798194403417
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  -13204.787     -13204.787     -13336.597     -13336.597      254.99445      254.99445      67600.546      67600.546     -967.17178     -967.17178    
     11000  -13210.02      -13210.02      -13340.766     -13340.766      252.93675      252.93675      67408.037      67408.037      903.53988      903.53988    
Loop time of 198.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.031 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.21     | 197.21     | 197.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11091    | 0.11091    | 0.11091    |   0.0 |  0.06
Output  | 0.00022948 | 0.00022948 | 0.00022948 |   0.0 |  0.00
Modify  | 0.69761    | 0.69761    | 0.69761    |   0.0 |  0.35
Other   |            | 0.09332    |            |       |  0.05

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

Total # of neighbors = 215054
Ave neighs/atom = 53.7635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.748969601964, Press = -3.88172391124443
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  -13210.02      -13210.02      -13340.766     -13340.766      252.93675      252.93675      67408.037      67408.037      903.53988      903.53988    
     12000  -13208.047     -13208.047     -13339.987     -13339.987      255.24591      255.24591      67461.765      67461.765      285.43325      285.43325    
Loop time of 195.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.436 hours/ns, 5.103 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    | 195.08     | 195.08     | 195.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1107     | 0.1107     | 0.1107     |   0.0 |  0.06
Output  | 0.0003014  | 0.0003014  | 0.0003014  |   0.0 |  0.00
Modify  | 0.6903     | 0.6903     | 0.6903     |   0.0 |  0.35
Other   |            | 0.09289    |            |       |  0.05

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

Total # of neighbors = 215118
Ave neighs/atom = 53.7795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.636289470345, Press = 2.75357352855559
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  -13208.047     -13208.047     -13339.987     -13339.987      255.24591      255.24591      67461.765      67461.765      285.43325      285.43325    
     13000  -13211.001     -13211.001     -13342.713     -13342.713      254.80501      254.80501      67528.933      67528.933     -584.74343     -584.74343    
Loop time of 196.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.654 hours/ns, 5.082 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.86     | 195.86     | 195.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11135    | 0.11135    | 0.11135    |   0.0 |  0.06
Output  | 0.00022691 | 0.00022691 | 0.00022691 |   0.0 |  0.00
Modify  | 0.69387    | 0.69387    | 0.69387    |   0.0 |  0.35
Other   |            | 0.09409    |            |       |  0.05

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

Total # of neighbors = 215194
Ave neighs/atom = 53.7985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.699526796634, Press = -1.07317513436006
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13211.001     -13211.001     -13342.713     -13342.713      254.80501      254.80501      67528.933      67528.933     -584.74343     -584.74343    
     14000  -13210.654     -13210.654     -13340.981     -13340.981      252.12597      252.12597      67459.279      67459.279      151.4601       151.4601     
Loop time of 196.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.672 hours/ns, 5.081 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    | 195.92     | 195.92     | 195.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10953    | 0.10953    | 0.10953    |   0.0 |  0.06
Output  | 0.00044849 | 0.00044849 | 0.00044849 |   0.0 |  0.00
Modify  | 0.69305    | 0.69305    | 0.69305    |   0.0 |  0.35
Other   |            | 0.09336    |            |       |  0.05

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

Total # of neighbors = 215168
Ave neighs/atom = 53.792
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.763094227514, Press = -1.08609920733694
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  -13210.654     -13210.654     -13340.981     -13340.981      252.12597      252.12597      67459.279      67459.279      151.4601       151.4601     
     15000  -13207.361     -13207.361     -13338.529     -13338.529      253.75408      253.75408      67524.376      67524.376     -283.01252     -283.01252    
Loop time of 197.674 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.910 hours/ns, 5.059 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    | 196.78     | 196.78     | 196.78     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1098     | 0.1098     | 0.1098     |   0.0 |  0.06
Output  | 0.00020829 | 0.00020829 | 0.00020829 |   0.0 |  0.00
Modify  | 0.69559    | 0.69559    | 0.69559    |   0.0 |  0.35
Other   |            | 0.09333    |            |       |  0.05

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

Total # of neighbors = 215154
Ave neighs/atom = 53.7885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.817400161273, Press = 2.24557405277477
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  -13207.361     -13207.361     -13338.529     -13338.529      253.75408      253.75408      67524.376      67524.376     -283.01252     -283.01252    
     16000  -13204.396     -13204.396     -13339.715     -13339.715      261.78352      261.78352      67588.737      67588.737     -997.50175     -997.50175    
Loop time of 196.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.583 hours/ns, 5.089 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    | 195.61     | 195.61     | 195.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11011    | 0.11011    | 0.11011    |   0.0 |  0.06
Output  | 0.00018798 | 0.00018798 | 0.00018798 |   0.0 |  0.00
Modify  | 0.68749    | 0.68749    | 0.68749    |   0.0 |  0.35
Other   |            | 0.09288    |            |       |  0.05

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

Total # of neighbors = 215076
Ave neighs/atom = 53.769
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.771361284811, Press = -3.44897552735844
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  -13204.396     -13204.396     -13339.715     -13339.715      261.78352      261.78352      67588.737      67588.737     -997.50175     -997.50175    
     17000  -13209.831     -13209.831     -13340.234     -13340.234      252.27478      252.27478      67433.291      67433.291      662.99675      662.99675    
Loop time of 196.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.717 hours/ns, 5.077 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    | 196.08     | 196.08     | 196.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11038    | 0.11038    | 0.11038    |   0.0 |  0.06
Output  | 0.00018777 | 0.00018777 | 0.00018777 |   0.0 |  0.00
Modify  | 0.69339    | 0.69339    | 0.69339    |   0.0 |  0.35
Other   |            | 0.09313    |            |       |  0.05

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

Total # of neighbors = 215080
Ave neighs/atom = 53.77
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.837546600193, Press = 0.442840882975764
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  -13209.831     -13209.831     -13340.234     -13340.234      252.27478      252.27478      67433.291      67433.291      662.99675      662.99675    
     18000  -13204.493     -13204.493     -13337.917     -13337.917      258.11712      258.11712      67564.926      67564.926     -742.07604     -742.07604    
Loop time of 196.166 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.491 hours/ns, 5.098 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    | 195.27     | 195.27     | 195.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10942    | 0.10942    | 0.10942    |   0.0 |  0.06
Output  | 0.00024796 | 0.00024796 | 0.00024796 |   0.0 |  0.00
Modify  | 0.68954    | 0.68954    | 0.68954    |   0.0 |  0.35
Other   |            | 0.0924     |            |       |  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:       215118 ave      215118 max      215118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215118
Ave neighs/atom = 53.7795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.899980609574, Press = 0.00374860994877452
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13204.493     -13204.493     -13337.917     -13337.917      258.11712      258.11712      67564.926      67564.926     -742.07604     -742.07604    
     19000  -13211.004     -13211.004     -13338.335     -13338.335      246.33051      246.33051      67467.878      67467.878      176.22596      176.22596    
Loop time of 197.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.877 hours/ns, 5.062 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    | 196.66     | 196.66     | 196.66     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10961    | 0.10961    | 0.10961    |   0.0 |  0.06
Output  | 0.00018649 | 0.00018649 | 0.00018649 |   0.0 |  0.00
Modify  | 0.69613    | 0.69613    | 0.69613    |   0.0 |  0.35
Other   |            | 0.09273    |            |       |  0.05

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

Total # of neighbors = 215082
Ave neighs/atom = 53.7705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.866044997203, Press = -1.67678791029121
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  -13211.004     -13211.004     -13338.335     -13338.335      246.33051      246.33051      67467.878      67467.878      176.22596      176.22596    
     20000  -13206.906     -13206.906     -13336.613     -13336.613      250.92811      250.92811      67492.596      67492.596      132.12133      132.12133    
Loop time of 197.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.872 hours/ns, 5.062 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    | 196.64     | 196.64     | 196.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11177    | 0.11177    | 0.11177    |   0.0 |  0.06
Output  | 0.00018732 | 0.00018732 | 0.00018732 |   0.0 |  0.00
Modify  | 0.69624    | 0.69624    | 0.69624    |   0.0 |  0.35
Other   |            | 0.0943     |            |       |  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:       215068 ave      215068 max      215068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215068
Ave neighs/atom = 53.767
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.80650356329, Press = 1.59625004071178
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  -13206.906     -13206.906     -13336.613     -13336.613      250.92811      250.92811      67492.596      67492.596      132.12133      132.12133    
     21000  -13211.588     -13211.588     -13342.087     -13342.087      252.45889      252.45889      67571.393      67571.393     -869.96042     -869.96042    
Loop time of 198.109 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.030 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.2      | 197.2      | 197.2      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11115    | 0.11115    | 0.11115    |   0.0 |  0.06
Output  | 0.00018834 | 0.00018834 | 0.00018834 |   0.0 |  0.00
Modify  | 0.70573    | 0.70573    | 0.70573    |   0.0 |  0.36
Other   |            | 0.09492    |            |       |  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:       215102 ave      215102 max      215102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215102
Ave neighs/atom = 53.7755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.677288825266, Press = -1.78637986251897
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  -13211.588     -13211.588     -13342.087     -13342.087      252.45889      252.45889      67571.393      67571.393     -869.96042     -869.96042    
     22000  -13207.499     -13207.499     -13341.281     -13341.281      258.81113      258.81113      67407.901      67407.901      1054.3092      1054.3092    
Loop time of 196.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.559 hours/ns, 5.091 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    | 195.51     | 195.51     | 195.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10959    | 0.10959    | 0.10959    |   0.0 |  0.06
Output  | 0.00021295 | 0.00021295 | 0.00021295 |   0.0 |  0.00
Modify  | 0.69417    | 0.69417    | 0.69417    |   0.0 |  0.35
Other   |            | 0.09344    |            |       |  0.05

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

Total # of neighbors = 215098
Ave neighs/atom = 53.7745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.591835917136, Press = 0.259094121897912
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  -13207.499     -13207.499     -13341.281     -13341.281      258.81113      258.81113      67407.901      67407.901      1054.3092      1054.3092    
     23000  -13214.365     -13214.365     -13343.814     -13343.814      250.42712      250.42712      67484.615      67484.615      28.240415      28.240415    
Loop time of 197.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.747 hours/ns, 5.074 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.19     | 196.19     | 196.19     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11057    | 0.11057    | 0.11057    |   0.0 |  0.06
Output  | 0.00018851 | 0.00018851 | 0.00018851 |   0.0 |  0.00
Modify  | 0.69238    | 0.69238    | 0.69238    |   0.0 |  0.35
Other   |            | 0.0939     |            |       |  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:       215250 ave      215250 max      215250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215250
Ave neighs/atom = 53.8125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.519944320498, Press = 0.537972161230052
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  -13214.365     -13214.365     -13343.814     -13343.814      250.42712      250.42712      67484.615      67484.615      28.240415      28.240415    
     24000  -13208.044     -13208.044     -13337.834     -13337.834      251.08721      251.08721      67500.421      67500.421      66.115646      66.115646    
Loop time of 197.963 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.990 hours/ns, 5.051 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    | 197.06     | 197.06     | 197.06     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10996    | 0.10996    | 0.10996    |   0.0 |  0.06
Output  | 0.00018537 | 0.00018537 | 0.00018537 |   0.0 |  0.00
Modify  | 0.69687    | 0.69687    | 0.69687    |   0.0 |  0.35
Other   |            | 0.09399    |            |       |  0.05

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

Total # of neighbors = 215214
Ave neighs/atom = 53.8035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.532453932261, Press = -0.139857365915777
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  -13208.044     -13208.044     -13337.834     -13337.834      251.08721      251.08721      67500.421      67500.421      66.115646      66.115646    
     25000  -13207.417     -13207.417     -13338.425     -13338.425      253.44338      253.44338      67531.32       67531.32      -339.92808     -339.92808    
Loop time of 198.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.136 hours/ns, 5.038 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    | 197.59     | 197.59     | 197.59     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11017    | 0.11017    | 0.11017    |   0.0 |  0.06
Output  | 0.0001856  | 0.0001856  | 0.0001856  |   0.0 |  0.00
Modify  | 0.69761    | 0.69761    | 0.69761    |   0.0 |  0.35
Other   |            | 0.09361    |            |       |  0.05

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

Total # of neighbors = 215094
Ave neighs/atom = 53.7735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.545787125975, Press = 0.487764925805423
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13207.417     -13207.417     -13338.425     -13338.425      253.44338      253.44338      67531.32       67531.32      -339.92808     -339.92808    
     26000  -13211.362     -13211.362     -13343.414     -13343.414      255.46435      255.46435      67468.843      67468.843      311.46153      311.46153    
Loop time of 198.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.162 hours/ns, 5.036 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    | 197.68     | 197.68     | 197.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11061    | 0.11061    | 0.11061    |   0.0 |  0.06
Output  | 0.00018606 | 0.00018606 | 0.00018606 |   0.0 |  0.00
Modify  | 0.70036    | 0.70036    | 0.70036    |   0.0 |  0.35
Other   |            | 0.09386    |            |       |  0.05

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

Total # of neighbors = 215098
Ave neighs/atom = 53.7745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.587895389116, Press = -2.08534365763435
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  -13211.362     -13211.362     -13343.414     -13343.414      255.46435      255.46435      67468.843      67468.843      311.46153      311.46153    
     27000  -13208.299     -13208.299     -13340.208     -13340.208      255.18721      255.18721      67405.16       67405.16       1259.8873      1259.8873    
Loop time of 198.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.277 hours/ns, 5.025 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    | 198.09     | 198.09     | 198.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11127    | 0.11127    | 0.11127    |   0.0 |  0.06
Output  | 0.00018661 | 0.00018661 | 0.00018661 |   0.0 |  0.00
Modify  | 0.70431    | 0.70431    | 0.70431    |   0.0 |  0.35
Other   |            | 0.09395    |            |       |  0.05

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

Total # of neighbors = 215220
Ave neighs/atom = 53.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.581891694093, Press = 2.21664837973912
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  -13208.299     -13208.299     -13340.208     -13340.208      255.18721      255.18721      67405.16       67405.16       1259.8873      1259.8873    
     28000  -13209.413     -13209.413     -13337.911     -13337.911      248.58626      248.58626      67562.939      67562.939     -622.42714     -622.42714    
Loop time of 197.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.875 hours/ns, 5.062 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    | 196.65     | 196.65     | 196.65     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11067    | 0.11067    | 0.11067    |   0.0 |  0.06
Output  | 0.00018786 | 0.00018786 | 0.00018786 |   0.0 |  0.00
Modify  | 0.69283    | 0.69283    | 0.69283    |   0.0 |  0.35
Other   |            | 0.09417    |            |       |  0.05

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

Total # of neighbors = 215196
Ave neighs/atom = 53.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.552874072355, Press = -0.229480102316765
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  -13209.413     -13209.413     -13337.911     -13337.911      248.58626      248.58626      67562.939      67562.939     -622.42714     -622.42714    
     29000  -13208.431     -13208.431     -13340.598     -13340.598      255.68612      255.68612      67441.648      67441.648      648.49806      648.49806    
Loop time of 197.327 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.813 hours/ns, 5.068 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    | 196.43     | 196.43     | 196.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11075    | 0.11075    | 0.11075    |   0.0 |  0.06
Output  | 0.0001884  | 0.0001884  | 0.0001884  |   0.0 |  0.00
Modify  | 0.69415    | 0.69415    | 0.69415    |   0.0 |  0.35
Other   |            | 0.09367    |            |       |  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:       215094 ave      215094 max      215094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215094
Ave neighs/atom = 53.7735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.519562339135, Press = -0.289003198865628
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13208.431     -13208.431     -13340.598     -13340.598      255.68612      255.68612      67441.648      67441.648      648.49806      648.49806    
     30000  -13208.533     -13208.533     -13340.168     -13340.168      254.65801      254.65801      67517.118      67517.118     -117.82019     -117.82019    
Loop time of 197.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.816 hours/ns, 5.067 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    | 196.44     | 196.44     | 196.44     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10931    | 0.10931    | 0.10931    |   0.0 |  0.06
Output  | 0.00018778 | 0.00018778 | 0.00018778 |   0.0 |  0.00
Modify  | 0.69265    | 0.69265    | 0.69265    |   0.0 |  0.35
Other   |            | 0.09301    |            |       |  0.05

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

Total # of neighbors = 215146
Ave neighs/atom = 53.7865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.557021404932, Press = 1.29877307969537
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  -13208.533     -13208.533     -13340.168     -13340.168      254.65801      254.65801      67517.118      67517.118     -117.82019     -117.82019    
     31000  -13205.413     -13205.413     -13339.781     -13339.781      259.94402      259.94402      67565.754      67565.754     -659.00629     -659.00629    
Loop time of 197.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.730 hours/ns, 5.075 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    | 196.13     | 196.13     | 196.13     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1091     | 0.1091     | 0.1091     |   0.0 |  0.06
Output  | 0.00018748 | 0.00018748 | 0.00018748 |   0.0 |  0.00
Modify  | 0.69364    | 0.69364    | 0.69364    |   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:           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:       215132 ave      215132 max      215132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215132
Ave neighs/atom = 53.783
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.56254474441, Press = -0.245923957199009
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  -13205.413     -13205.413     -13339.781     -13339.781      259.94402      259.94402      67565.754      67565.754     -659.00629     -659.00629    
     32000  -13206.704     -13206.704     -13337.736     -13337.736      253.4895       253.4895       67468.99       67468.99       480.30014      480.30014    
Loop time of 198.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.056 hours/ns, 5.045 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    | 197.3      | 197.3      | 197.3      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11028    | 0.11028    | 0.11028    |   0.0 |  0.06
Output  | 0.00018937 | 0.00018937 | 0.00018937 |   0.0 |  0.00
Modify  | 0.69785    | 0.69785    | 0.69785    |   0.0 |  0.35
Other   |            | 0.09397    |            |       |  0.05

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

Total # of neighbors = 215078
Ave neighs/atom = 53.7695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.58959217737, Press = 0.292910772230241
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  -13206.704     -13206.704     -13337.736     -13337.736      253.4895       253.4895       67468.99       67468.99       480.30014      480.30014    
     33000  -13211.451     -13211.451     -13337.378     -13337.378      243.61549      243.61549      67519.164      67519.164     -198.3083      -198.3083     
Loop time of 197.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.833 hours/ns, 5.066 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    | 196.5      | 196.5      | 196.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11064    | 0.11064    | 0.11064    |   0.0 |  0.06
Output  | 0.00018502 | 0.00018502 | 0.00018502 |   0.0 |  0.00
Modify  | 0.69788    | 0.69788    | 0.69788    |   0.0 |  0.35
Other   |            | 0.09362    |            |       |  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:       215162 ave      215162 max      215162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215162
Ave neighs/atom = 53.7905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.545717103776, Press = 0.0417224825289601
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  -13211.451     -13211.451     -13337.378     -13337.378      243.61549      243.61549      67519.164      67519.164     -198.3083      -198.3083     
     34000  -13208.199     -13208.199     -13337.731     -13337.731      250.58835      250.58835      67385.436      67385.436      1506.7735      1506.7735    
Loop time of 196.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.675 hours/ns, 5.081 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    | 195.93     | 195.93     | 195.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10948    | 0.10948    | 0.10948    |   0.0 |  0.06
Output  | 0.0001881  | 0.0001881  | 0.0001881  |   0.0 |  0.00
Modify  | 0.69309    | 0.69309    | 0.69309    |   0.0 |  0.35
Other   |            | 0.09331    |            |       |  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:       215088 ave      215088 max      215088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215088
Ave neighs/atom = 53.772
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.512461509129, Press = -0.441072193321105
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  -13208.199     -13208.199     -13337.731     -13337.731      250.58835      250.58835      67385.436      67385.436      1506.7735      1506.7735    
     35000  -13204.084     -13204.084     -13338.729     -13338.729      260.47989      260.47989      67524.006      67524.006     -185.03179     -185.03179    
Loop time of 197.171 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.770 hours/ns, 5.072 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    | 196.27     | 196.27     | 196.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11053    | 0.11053    | 0.11053    |   0.0 |  0.06
Output  | 0.0001882  | 0.0001882  | 0.0001882  |   0.0 |  0.00
Modify  | 0.69251    | 0.69251    | 0.69251    |   0.0 |  0.35
Other   |            | 0.0936     |            |       |  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:       215098 ave      215098 max      215098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215098
Ave neighs/atom = 53.7745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.50358673924, Press = 1.59009678484994
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  -13204.084     -13204.084     -13338.729     -13338.729      260.47989      260.47989      67524.006      67524.006     -185.03179     -185.03179    
     36000  -13210.145     -13210.145     -13340.391     -13340.391      251.96941      251.96941      67553.274      67553.274     -808.96022     -808.96022    
Loop time of 198.057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.016 hours/ns, 5.049 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    | 197.15     | 197.15     | 197.15     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11086    | 0.11086    | 0.11086    |   0.0 |  0.06
Output  | 0.00018673 | 0.00018673 | 0.00018673 |   0.0 |  0.00
Modify  | 0.70026    | 0.70026    | 0.70026    |   0.0 |  0.35
Other   |            | 0.09427    |            |       |  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:       215116 ave      215116 max      215116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215116
Ave neighs/atom = 53.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.534788964864, Press = -0.447156514161872
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13210.145     -13210.145     -13340.391     -13340.391      251.96941      251.96941      67553.274      67553.274     -808.96022     -808.96022    
     37000  -13203.835     -13203.835     -13335.732     -13335.732      255.16392      255.16392      67486.834      67486.834      375.8467       375.8467     
Loop time of 196.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.668 hours/ns, 5.081 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    | 195.91     | 195.91     | 195.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11122    | 0.11122    | 0.11122    |   0.0 |  0.06
Output  | 0.00018875 | 0.00018875 | 0.00018875 |   0.0 |  0.00
Modify  | 0.69484    | 0.69484    | 0.69484    |   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:           3989 ave        3989 max        3989 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:       215124 ave      215124 max      215124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215124
Ave neighs/atom = 53.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.556249270982, Press = 0.545381829756419
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  -13203.835     -13203.835     -13335.732     -13335.732      255.16392      255.16392      67486.834      67486.834      375.8467       375.8467     
     38000  -13208.633     -13208.633     -13340.042     -13340.042      254.22009      254.22009      67533.82       67533.82      -359.93825     -359.93825    
Loop time of 198.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.074 hours/ns, 5.044 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    | 197.36     | 197.36     | 197.36     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11146    | 0.11146    | 0.11146    |   0.0 |  0.06
Output  | 0.0002325  | 0.0002325  | 0.0002325  |   0.0 |  0.00
Modify  | 0.70316    | 0.70316    | 0.70316    |   0.0 |  0.35
Other   |            | 0.09439    |            |       |  0.05

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

Total # of neighbors = 215048
Ave neighs/atom = 53.762
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.553217766717, Press = -0.1970980848546
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  -13208.633     -13208.633     -13340.042     -13340.042      254.22009      254.22009      67533.82       67533.82      -359.93825     -359.93825    
     39000  -13213.243     -13213.243     -13342.923     -13342.923      250.87551      250.87551      67463.193      67463.193      167.90398      167.90398    
Loop time of 197.043 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.734 hours/ns, 5.075 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    | 196.14     | 196.14     | 196.14     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11019    | 0.11019    | 0.11019    |   0.0 |  0.06
Output  | 0.00018888 | 0.00018888 | 0.00018888 |   0.0 |  0.00
Modify  | 0.69501    | 0.69501    | 0.69501    |   0.0 |  0.35
Other   |            | 0.09353    |            |       |  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:       215156 ave      215156 max      215156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215156
Ave neighs/atom = 53.789
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.524454381076, Press = -0.0826053518616026
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  -13213.243     -13213.243     -13342.923     -13342.923      250.87551      250.87551      67463.193      67463.193      167.90398      167.90398    
     40000  -13206.907     -13206.907     -13341.851     -13341.851      261.05797      261.05797      67506.584      67506.584     -31.629276     -31.629276    
Loop time of 196.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.639 hours/ns, 5.084 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    | 195.8      | 195.8      | 195.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10987    | 0.10987    | 0.10987    |   0.0 |  0.06
Output  | 0.00018712 | 0.00018712 | 0.00018712 |   0.0 |  0.00
Modify  | 0.69171    | 0.69171    | 0.69171    |   0.0 |  0.35
Other   |            | 0.09407    |            |       |  0.05

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

Total # of neighbors = 215166
Ave neighs/atom = 53.7915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.492800386345, Press = 0.611510864254308
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  -13206.907     -13206.907     -13341.851     -13341.851      261.05797      261.05797      67506.584      67506.584     -31.629276     -31.629276    
     41000  -13210.266     -13210.266     -13342.665     -13342.665      256.1346       256.1346       67567.681      67567.681     -739.92923     -739.92923    
Loop time of 197.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.841 hours/ns, 5.065 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.53     | 196.53     | 196.53     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.06
Output  | 0.00018645 | 0.00018645 | 0.00018645 |   0.0 |  0.00
Modify  | 0.69594    | 0.69594    | 0.69594    |   0.0 |  0.35
Other   |            | 0.09335    |            |       |  0.05

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

Total # of neighbors = 215148
Ave neighs/atom = 53.787
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.454053387074, Press = -0.433923076527925
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  -13210.266     -13210.266     -13342.665     -13342.665      256.1346       256.1346       67567.681      67567.681     -739.92923     -739.92923    
     42000  -13208.072     -13208.072     -13340.091     -13340.091      255.39907      255.39907      67415.755      67415.755      1198.5991      1198.5991    
Loop time of 197.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.758 hours/ns, 5.073 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    | 196.23     | 196.23     | 196.23     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10931    | 0.10931    | 0.10931    |   0.0 |  0.06
Output  | 0.00018637 | 0.00018637 | 0.00018637 |   0.0 |  0.00
Modify  | 0.69366    | 0.69366    | 0.69366    |   0.0 |  0.35
Other   |            | 0.09433    |            |       |  0.05

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

Total # of neighbors = 215120
Ave neighs/atom = 53.78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.431266282963, Press = 0.17582629429183
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  -13208.072     -13208.072     -13340.091     -13340.091      255.39907      255.39907      67415.755      67415.755      1198.5991      1198.5991    
     43000  -13211.084     -13211.084     -13341.3       -13341.3        251.91313      251.91313      67505.902      67505.902     -294.33254     -294.33254    
Loop time of 198.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.095 hours/ns, 5.042 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.44     | 197.44     | 197.44     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11087    | 0.11087    | 0.11087    |   0.0 |  0.06
Output  | 0.00026151 | 0.00026151 | 0.00026151 |   0.0 |  0.00
Modify  | 0.70115    | 0.70115    | 0.70115    |   0.0 |  0.35
Other   |            | 0.09382    |            |       |  0.05

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

Total # of neighbors = 215116
Ave neighs/atom = 53.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.430174061346, Press = 0.536108820744915
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13211.084     -13211.084     -13341.3       -13341.3        251.91313      251.91313      67505.902      67505.902     -294.33254     -294.33254    
     44000  -13201.86      -13201.86      -13336.729     -13336.729      260.91316      260.91316      67553.259      67553.259     -264.48148     -264.48148    
Loop time of 197.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.895 hours/ns, 5.060 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    | 196.72     | 196.72     | 196.72     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11035    | 0.11035    | 0.11035    |   0.0 |  0.06
Output  | 0.00018658 | 0.00018658 | 0.00018658 |   0.0 |  0.00
Modify  | 0.70013    | 0.70013    | 0.70013    |   0.0 |  0.35
Other   |            | 0.09357    |            |       |  0.05

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

Total # of neighbors = 215208
Ave neighs/atom = 53.802
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.441349435426, Press = -0.0726542853214448
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  -13201.86      -13201.86      -13336.729     -13336.729      260.91316      260.91316      67553.259      67553.259     -264.48148     -264.48148    
     45000  -13211.284     -13211.284     -13342.203     -13342.203      253.27314      253.27314      67437.577      67437.577      619.05624      619.05624    
Loop time of 197.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.822 hours/ns, 5.067 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    | 196.46     | 196.46     | 196.46     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10955    | 0.10955    | 0.10955    |   0.0 |  0.06
Output  | 0.00018795 | 0.00018795 | 0.00018795 |   0.0 |  0.00
Modify  | 0.6935     | 0.6935     | 0.6935     |   0.0 |  0.35
Other   |            | 0.09389    |            |       |  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:       215020 ave      215020 max      215020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215020
Ave neighs/atom = 53.755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.468286537658, Press = 0.0309215506217075
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  -13211.284     -13211.284     -13342.203     -13342.203      253.27314      253.27314      67437.577      67437.577      619.05624      619.05624    
     46000  -13205.619     -13205.619     -13337.828     -13337.828      255.76804      255.76804      67495.778      67495.778      77.669229      77.669229    
Loop time of 196.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.459 hours/ns, 5.101 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    | 195.16     | 195.16     | 195.16     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.06
Output  | 0.00018627 | 0.00018627 | 0.00018627 |   0.0 |  0.00
Modify  | 0.68565    | 0.68565    | 0.68565    |   0.0 |  0.35
Other   |            | 0.09379    |            |       |  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:       215148 ave      215148 max      215148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215148
Ave neighs/atom = 53.787
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.486448695384, Press = 0.958125157618904
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13205.619     -13205.619     -13337.828     -13337.828      255.76804      255.76804      67495.778      67495.778      77.669229      77.669229    
     47000  -13211.775     -13211.775     -13340.705     -13340.705      249.42405      249.42405      67623.13       67623.13      -1638.8252     -1638.8252    
Loop time of 197.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.935 hours/ns, 5.056 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    | 196.87     | 196.87     | 196.87     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10968    | 0.10968    | 0.10968    |   0.0 |  0.06
Output  | 0.00018865 | 0.00018865 | 0.00018865 |   0.0 |  0.00
Modify  | 0.69641    | 0.69641    | 0.69641    |   0.0 |  0.35
Other   |            | 0.09412    |            |       |  0.05

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

Total # of neighbors = 215068
Ave neighs/atom = 53.767
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.494884996748, Press = -0.408983582554601
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   
     47000  -13211.775     -13211.775     -13340.705     -13340.705      249.42405      249.42405      67623.13       67623.13      -1638.8252     -1638.8252    
     48000  -13205.279     -13205.279     -13338.49      -13338.49       257.7049       257.7049       67385.811      67385.811      1430.4107      1430.4107    
Loop time of 198.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.051 hours/ns, 5.046 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    | 197.27     | 197.27     | 197.27     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1117     | 0.1117     | 0.1117     |   0.0 |  0.06
Output  | 0.00018961 | 0.00018961 | 0.00018961 |   0.0 |  0.00
Modify  | 0.7049     | 0.7049     | 0.7049     |   0.0 |  0.36
Other   |            | 0.09455    |            |       |  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:       215046 ave      215046 max      215046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215046
Ave neighs/atom = 53.7615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.501743078516, Press = -0.099316272532516
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   
     48000  -13205.279     -13205.279     -13338.49      -13338.49       257.7049       257.7049       67385.811      67385.811      1430.4107      1430.4107    
     49000  -13209.293     -13209.293     -13338.92      -13338.92       250.77221      250.77221      67494.601      67494.601      19.075703      19.075703    
Loop time of 196.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.559 hours/ns, 5.091 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    | 195.52     | 195.52     | 195.52     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11105    | 0.11105    | 0.11105    |   0.0 |  0.06
Output  | 0.00018904 | 0.00018904 | 0.00018904 |   0.0 |  0.00
Modify  | 0.69106    | 0.69106    | 0.69106    |   0.0 |  0.35
Other   |            | 0.09307    |            |       |  0.05

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

Total # of neighbors = 215160
Ave neighs/atom = 53.79
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.503365761777, Press = 0.531196185497116
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   
     49000  -13209.293     -13209.293     -13338.92      -13338.92       250.77221      250.77221      67494.601      67494.601      19.075703      19.075703    
     50000  -13209.905     -13209.905     -13339.589     -13339.589      250.88176      250.88176      67484.964      67484.964      106.27324      106.27324    
Loop time of 198.091 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.025 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.19     | 197.19     | 197.19     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10929    | 0.10929    | 0.10929    |   0.0 |  0.06
Output  | 0.00018856 | 0.00018856 | 0.00018856 |   0.0 |  0.00
Modify  | 0.69871    | 0.69871    | 0.69871    |   0.0 |  0.35
Other   |            | 0.09316    |            |       |  0.05

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

Total # of neighbors = 215100
Ave neighs/atom = 53.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.535280394902, Press = 0.196766005334275
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   
     50000  -13209.905     -13209.905     -13339.589     -13339.589      250.88176      250.88176      67484.964      67484.964      106.27324      106.27324    
     51000  -13206.884     -13206.884     -13338.316     -13338.316      254.26411      254.26411      67484.298      67484.298      124.46068      124.46068    
Loop time of 199.313 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.365 hours/ns, 5.017 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    | 198.41     | 198.41     | 198.41     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11019    | 0.11019    | 0.11019    |   0.0 |  0.06
Output  | 0.00018792 | 0.00018792 | 0.00018792 |   0.0 |  0.00
Modify  | 0.70202    | 0.70202    | 0.70202    |   0.0 |  0.35
Other   |            | 0.09387    |            |       |  0.05

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

Total # of neighbors = 215086
Ave neighs/atom = 53.7715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.531173104882, Press = 0.160892192968726
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   
     51000  -13206.884     -13206.884     -13338.316     -13338.316      254.26411      254.26411      67484.298      67484.298      124.46068      124.46068    
     52000  -13212.938     -13212.938     -13341.432     -13341.432      248.57884      248.57884      67446.169      67446.169      347.81261      347.81261    
Loop time of 197.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.973 hours/ns, 5.053 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    | 197        | 197        | 197        |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10974    | 0.10974    | 0.10974    |   0.0 |  0.06
Output  | 0.00055888 | 0.00055888 | 0.00055888 |   0.0 |  0.00
Modify  | 0.69784    | 0.69784    | 0.69784    |   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:           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:       215042 ave      215042 max      215042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215042
Ave neighs/atom = 53.7605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.514355799757, Press = 0.259523525225999
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   
     52000  -13212.938     -13212.938     -13341.432     -13341.432      248.57884      248.57884      67446.169      67446.169      347.81261      347.81261    
     53000  -13208.191     -13208.191     -13339.977     -13339.977      254.94824      254.94824      67558.071      67558.071     -744.32735     -744.32735    
Loop time of 199.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.424 hours/ns, 5.012 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    | 198.61     | 198.61     | 198.61     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11171    | 0.11171    | 0.11171    |   0.0 |  0.06
Output  | 0.00024826 | 0.00024826 | 0.00024826 |   0.0 |  0.00
Modify  | 0.70875    | 0.70875    | 0.70875    |   0.0 |  0.36
Other   |            | 0.09451    |            |       |  0.05

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

Total # of neighbors = 215170
Ave neighs/atom = 53.7925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.475483287385, Press = 0.0725061386579487
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13208.191     -13208.191     -13339.977     -13339.977      254.94824      254.94824      67558.071      67558.071     -744.32735     -744.32735    
     54000  -13212.956     -13212.956     -13341.337     -13341.337      248.36193      248.36193      67430.03       67430.03       735.03164      735.03164    
Loop time of 199.615 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.449 hours/ns, 5.010 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    | 198.71     | 198.71     | 198.71     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10974    | 0.10974    | 0.10974    |   0.0 |  0.05
Output  | 0.00025622 | 0.00025622 | 0.00025622 |   0.0 |  0.00
Modify  | 0.70337    | 0.70337    | 0.70337    |   0.0 |  0.35
Other   |            | 0.09367    |            |       |  0.05

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

Total # of neighbors = 215170
Ave neighs/atom = 53.7925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.444643649224, Press = -0.483178190822477
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   
     54000  -13212.956     -13212.956     -13341.337     -13341.337      248.36193      248.36193      67430.03       67430.03       735.03164      735.03164    
     55000  -13209.104     -13209.104     -13338.923     -13338.923      251.14461      251.14461      67469.146      67469.146      354.81162      354.81162    
Loop time of 199.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.294 hours/ns, 5.024 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    | 198.15     | 198.15     | 198.15     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11058    | 0.11058    | 0.11058    |   0.0 |  0.06
Output  | 0.00023299 | 0.00023299 | 0.00023299 |   0.0 |  0.00
Modify  | 0.70551    | 0.70551    | 0.70551    |   0.0 |  0.35
Other   |            | 0.09387    |            |       |  0.05

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

Total # of neighbors = 215188
Ave neighs/atom = 53.797
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.440632853002, Press = 0.772615776270256
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   
     55000  -13209.104     -13209.104     -13338.923     -13338.923      251.14461      251.14461      67469.146      67469.146      354.81162      354.81162    
     56000  -13211.216     -13211.216     -13340.345     -13340.345      249.80832      249.80832      67537.955      67537.955     -652.59517     -652.59517    
Loop time of 200.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.577 hours/ns, 4.998 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    | 199.16     | 199.16     | 199.16     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11188    | 0.11188    | 0.11188    |   0.0 |  0.06
Output  | 0.00018654 | 0.00018654 | 0.00018654 |   0.0 |  0.00
Modify  | 0.70854    | 0.70854    | 0.70854    |   0.0 |  0.35
Other   |            | 0.09482    |            |       |  0.05

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

Total # of neighbors = 215152
Ave neighs/atom = 53.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.454200466491, Press = -0.01953347591219
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13211.216     -13211.216     -13340.345     -13340.345      249.80832      249.80832      67537.955      67537.955     -652.59517     -652.59517    
     57000  -13203.727     -13203.727     -13338.733     -13338.733      261.17831      261.17831      67482.551      67482.551      395.14332      395.14332    
Loop time of 199.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.492 hours/ns, 5.006 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    | 198.87     | 198.87     | 198.87     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10975    | 0.10975    | 0.10975    |   0.0 |  0.05
Output  | 0.00018694 | 0.00018694 | 0.00018694 |   0.0 |  0.00
Modify  | 0.70118    | 0.70118    | 0.70118    |   0.0 |  0.35
Other   |            | 0.09373    |            |       |  0.05

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

Total # of neighbors = 215092
Ave neighs/atom = 53.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.476522832245, Press = -0.0104878637066381
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   
     57000  -13203.727     -13203.727     -13338.733     -13338.733      261.17831      261.17831      67482.551      67482.551      395.14332      395.14332    
     58000  -13209.625     -13209.625     -13339.338     -13339.338      250.93894      250.93894      67500.621      67500.621     -48.009482     -48.009482    
Loop time of 200.159 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.600 hours/ns, 4.996 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.24     | 199.24     | 199.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11068    | 0.11068    | 0.11068    |   0.0 |  0.06
Output  | 0.00018822 | 0.00018822 | 0.00018822 |   0.0 |  0.00
Modify  | 0.71159    | 0.71159    | 0.71159    |   0.0 |  0.36
Other   |            | 0.09502    |            |       |  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:       215152 ave      215152 max      215152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215152
Ave neighs/atom = 53.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.480918260687, Press = 0.213311044064141
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   
     58000  -13209.625     -13209.625     -13339.338     -13339.338      250.93894      250.93894      67500.621      67500.621     -48.009482     -48.009482    
     59000  -13204.986     -13204.986     -13339.381     -13339.381      259.99552      259.99552      67539.052      67539.052     -318.63089     -318.63089    
Loop time of 199.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.472 hours/ns, 5.008 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.79     | 198.79     | 198.79     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11005    | 0.11005    | 0.11005    |   0.0 |  0.06
Output  | 0.00018518 | 0.00018518 | 0.00018518 |   0.0 |  0.00
Modify  | 0.70842    | 0.70842    | 0.70842    |   0.0 |  0.35
Other   |            | 0.09499    |            |       |  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:       215132 ave      215132 max      215132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215132
Ave neighs/atom = 53.783
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.502794298563, Press = 0.00532154010952107
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13204.986     -13204.986     -13339.381     -13339.381      259.99552      259.99552      67539.052      67539.052     -318.63089     -318.63089    
     60000  -13207.886     -13207.886     -13336.489     -13336.489      248.79211      248.79211      67424.099      67424.099      1042.4454      1042.4454    
Loop time of 197.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.967 hours/ns, 5.054 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.98     | 196.98     | 196.98     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10785    | 0.10785    | 0.10785    |   0.0 |  0.05
Output  | 0.00018662 | 0.00018662 | 0.00018662 |   0.0 |  0.00
Modify  | 0.6987     | 0.6987     | 0.6987     |   0.0 |  0.35
Other   |            | 0.09408    |            |       |  0.05

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

Total # of neighbors = 215152
Ave neighs/atom = 53.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.492748510901, Press = -0.31442851021301
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   
     60000  -13207.886     -13207.886     -13336.489     -13336.489      248.79211      248.79211      67424.099      67424.099      1042.4454      1042.4454    
     61000  -13208.349     -13208.349     -13338.658     -13338.658      252.0913       252.0913       67506.584      67506.584     -78.682801     -78.682801    
Loop time of 198.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.212 hours/ns, 5.031 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    | 197.86     | 197.86     | 197.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11057    | 0.11057    | 0.11057    |   0.0 |  0.06
Output  | 0.0002526  | 0.0002526  | 0.0002526  |   0.0 |  0.00
Modify  | 0.70181    | 0.70181    | 0.70181    |   0.0 |  0.35
Other   |            | 0.09383    |            |       |  0.05

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

Total # of neighbors = 215208
Ave neighs/atom = 53.802
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.471199120614, Press = 0.960210682468236
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13208.349     -13208.349     -13338.658     -13338.658      252.0913       252.0913       67506.584      67506.584     -78.682801     -78.682801    
     62000  -13213.663     -13213.663     -13342.28      -13342.28       248.81762      248.81762      67531.163      67531.163     -577.70678     -577.70678    
Loop time of 200.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.786 hours/ns, 4.979 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    | 199.91     | 199.91     | 199.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11136    | 0.11136    | 0.11136    |   0.0 |  0.06
Output  | 0.00018685 | 0.00018685 | 0.00018685 |   0.0 |  0.00
Modify  | 0.713      | 0.713      | 0.713      |   0.0 |  0.36
Other   |            | 0.095      |            |       |  0.05

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

Total # of neighbors = 215128
Ave neighs/atom = 53.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.437411548946, Press = -0.014069392502008
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   
     62000  -13213.663     -13213.663     -13342.28      -13342.28       248.81762      248.81762      67531.163      67531.163     -577.70678     -577.70678    
     63000  -13209.031     -13209.031     -13339.885     -13339.885      253.14614      253.14614      67468.702      67468.702      154.7531       154.7531     
Loop time of 198.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.240 hours/ns, 5.029 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    | 197.96     | 197.96     | 197.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1091     | 0.1091     | 0.1091     |   0.0 |  0.05
Output  | 0.00018917 | 0.00018917 | 0.00018917 |   0.0 |  0.00
Modify  | 0.69798    | 0.69798    | 0.69798    |   0.0 |  0.35
Other   |            | 0.09368    |            |       |  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:       215140 ave      215140 max      215140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215140
Ave neighs/atom = 53.785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.424500591717, Press = 0.235760372078688
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   
     63000  -13209.031     -13209.031     -13339.885     -13339.885      253.14614      253.14614      67468.702      67468.702      154.7531       154.7531     
     64000  -13210.631     -13210.631     -13339.945     -13339.945      250.16667      250.16667      67508.174      67508.174     -235.60372     -235.60372    
Loop time of 198.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.113 hours/ns, 5.040 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    | 197.5      | 197.5      | 197.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11053    | 0.11053    | 0.11053    |   0.0 |  0.06
Output  | 0.00018731 | 0.00018731 | 0.00018731 |   0.0 |  0.00
Modify  | 0.70224    | 0.70224    | 0.70224    |   0.0 |  0.35
Other   |            | 0.09454    |            |       |  0.05

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

Total # of neighbors = 215166
Ave neighs/atom = 53.7915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.392197570873, Press = 0.31856227902112
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   
     64000  -13210.631     -13210.631     -13339.945     -13339.945      250.16667      250.16667      67508.174      67508.174     -235.60372     -235.60372    
     65000  -13211.078     -13211.078     -13341.077     -13341.077      251.49197      251.49197      67452.534      67452.534      328.76113      328.76113    
Loop time of 200.417 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.671 hours/ns, 4.990 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    | 199.5      | 199.5      | 199.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11153    | 0.11153    | 0.11153    |   0.0 |  0.06
Output  | 0.00026494 | 0.00026494 | 0.00026494 |   0.0 |  0.00
Modify  | 0.71097    | 0.71097    | 0.71097    |   0.0 |  0.35
Other   |            | 0.09484    |            |       |  0.05

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

Total # of neighbors = 215144
Ave neighs/atom = 53.786
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.390185152149, Press = -0.0983973380941818
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   
     65000  -13211.078     -13211.078     -13341.077     -13341.077      251.49197      251.49197      67452.534      67452.534      328.76113      328.76113    
     66000  -13206.19      -13206.19      -13335.723     -13335.723      250.58996      250.58996      67523.454      67523.454     -86.124224     -86.124224    
Loop time of 198.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.276 hours/ns, 5.025 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    | 198.09     | 198.09     | 198.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10965    | 0.10965    | 0.10965    |   0.0 |  0.06
Output  | 0.0001884  | 0.0001884  | 0.0001884  |   0.0 |  0.00
Modify  | 0.70411    | 0.70411    | 0.70411    |   0.0 |  0.35
Other   |            | 0.0942     |            |       |  0.05

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

Total # of neighbors = 215144
Ave neighs/atom = 53.786
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.411093621294, Press = 0.462905826103134
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   
     66000  -13206.19      -13206.19      -13335.723     -13335.723      250.58996      250.58996      67523.454      67523.454     -86.124224     -86.124224    
     67000  -13209.128     -13209.128     -13341.642     -13341.642      256.3576       256.3576       67518.037      67518.037     -328.68388     -328.68388    
Loop time of 197.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.916 hours/ns, 5.058 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    | 196.79     | 196.79     | 196.79     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10962    | 0.10962    | 0.10962    |   0.0 |  0.06
Output  | 0.00022658 | 0.00022658 | 0.00022658 |   0.0 |  0.00
Modify  | 0.70099    | 0.70099    | 0.70099    |   0.0 |  0.35
Other   |            | 0.09436    |            |       |  0.05

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

Total # of neighbors = 215064
Ave neighs/atom = 53.766
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.415351961781, Press = -0.130301568205079
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   
     67000  -13209.128     -13209.128     -13341.642     -13341.642      256.3576       256.3576       67518.037      67518.037     -328.68388     -328.68388    
     68000  -13210.201     -13210.201     -13342.066     -13342.066      255.10298      255.10298      67414.118      67414.118      790.29424      790.29424    
Loop time of 200.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.624 hours/ns, 4.994 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    | 199.33     | 199.33     | 199.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11126    | 0.11126    | 0.11126    |   0.0 |  0.06
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.70757    | 0.70757    | 0.70757    |   0.0 |  0.35
Other   |            | 0.0947     |            |       |  0.05

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

Total # of neighbors = 215186
Ave neighs/atom = 53.7965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.435572452095, Press = 0.494117130356875
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13210.201     -13210.201     -13342.066     -13342.066      255.10298      255.10298      67414.118      67414.118      790.29424      790.29424    
     69000  -13209.911     -13209.911     -13338.337     -13338.337      248.44997      248.44997      67607.95       67607.95      -1254.0175     -1254.0175    
Loop time of 199.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.447 hours/ns, 5.010 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    | 198.69     | 198.69     | 198.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10992    | 0.10992    | 0.10992    |   0.0 |  0.06
Output  | 0.0001866  | 0.0001866  | 0.0001866  |   0.0 |  0.00
Modify  | 0.71076    | 0.71076    | 0.71076    |   0.0 |  0.36
Other   |            | 0.09426    |            |       |  0.05

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

Total # of neighbors = 215200
Ave neighs/atom = 53.8
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.432174336992, Press = 0.778271253643985
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   
     69000  -13209.911     -13209.911     -13338.337     -13338.337      248.44997      248.44997      67607.95       67607.95      -1254.0175     -1254.0175    
     70000  -13209.198     -13209.198     -13338.687     -13338.687      250.50454      250.50454      67499.639      67499.639     -90.582992     -90.582992    
Loop time of 200.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.565 hours/ns, 4.999 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    | 199.12     | 199.12     | 199.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10997    | 0.10997    | 0.10997    |   0.0 |  0.05
Output  | 0.0001885  | 0.0001885  | 0.0001885  |   0.0 |  0.00
Modify  | 0.71139    | 0.71139    | 0.71139    |   0.0 |  0.36
Other   |            | 0.09494    |            |       |  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:       215090 ave      215090 max      215090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215090
Ave neighs/atom = 53.7725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.435990105578, Press = -0.066446682630173
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   
     70000  -13209.198     -13209.198     -13338.687     -13338.687      250.50454      250.50454      67499.639      67499.639     -90.582992     -90.582992    
     71000  -13211.139     -13211.139     -13340.307     -13340.307      249.8839       249.8839       67525.977      67525.977     -390.27822     -390.27822    
Loop time of 199.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.425 hours/ns, 5.012 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    | 198.62     | 198.62     | 198.62     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10972    | 0.10972    | 0.10972    |   0.0 |  0.05
Output  | 0.00018619 | 0.00018619 | 0.00018619 |   0.0 |  0.00
Modify  | 0.70365    | 0.70365    | 0.70365    |   0.0 |  0.35
Other   |            | 0.09477    |            |       |  0.05

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

Total # of neighbors = 215172
Ave neighs/atom = 53.793
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.414296356602, Press = 0.296935970324932
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   
     71000  -13211.139     -13211.139     -13340.307     -13340.307      249.8839       249.8839       67525.977      67525.977     -390.27822     -390.27822    
     72000  -13208.614     -13208.614     -13340.142     -13340.142      254.44857      254.44857      67520.297      67520.297     -391.97907     -391.97907    
Loop time of 200.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.639 hours/ns, 4.992 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.39     | 199.39     | 199.39     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1114     | 0.1114     | 0.1114     |   0.0 |  0.06
Output  | 0.00022205 | 0.00022205 | 0.00022205 |   0.0 |  0.00
Modify  | 0.70654    | 0.70654    | 0.70654    |   0.0 |  0.35
Other   |            | 0.09579    |            |       |  0.05

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

Total # of neighbors = 215108
Ave neighs/atom = 53.777
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.413073529138, Press = -0.0228200813417235
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   
     72000  -13208.614     -13208.614     -13340.142     -13340.142      254.44857      254.44857      67520.297      67520.297     -391.97907     -391.97907    
     73000  -13210.939     -13210.939     -13342.036     -13342.036      253.61612      253.61612      67467.548      67467.548      200.50724      200.50724    
Loop time of 201.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.883 hours/ns, 4.971 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.26     | 200.26     | 200.26     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11131    | 0.11131    | 0.11131    |   0.0 |  0.06
Output  | 0.00018673 | 0.00018673 | 0.00018673 |   0.0 |  0.00
Modify  | 0.7124     | 0.7124     | 0.7124     |   0.0 |  0.35
Other   |            | 0.09481    |            |       |  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:       215140 ave      215140 max      215140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215140
Ave neighs/atom = 53.785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.417514444291, Press = 0.522881590767209
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   
     73000  -13210.939     -13210.939     -13342.036     -13342.036      253.61612      253.61612      67467.548      67467.548      200.50724      200.50724    
     74000  -13211.833     -13211.833     -13340.601     -13340.601      249.11009      249.11009      67555.686      67555.686     -921.27831     -921.27831    
Loop time of 200.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.787 hours/ns, 4.979 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    | 199.92     | 199.92     | 199.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11017    | 0.11017    | 0.11017    |   0.0 |  0.05
Output  | 0.0002323  | 0.0002323  | 0.0002323  |   0.0 |  0.00
Modify  | 0.71032    | 0.71032    | 0.71032    |   0.0 |  0.35
Other   |            | 0.09533    |            |       |  0.05

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

Total # of neighbors = 215154
Ave neighs/atom = 53.7885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.419408050841, Press = 0.0114261679034255
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.144 | 4.144 | 4.144 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13211.833     -13211.833     -13340.601     -13340.601      249.11009      249.11009      67555.686      67555.686     -921.27831     -921.27831    
     75000  -13208.92      -13208.92      -13339.93      -13339.93       253.44691      253.44691      67462.427      67462.427      374.65936      374.65936    
Loop time of 200.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.666 hours/ns, 4.990 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    | 199.49     | 199.49     | 199.49     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11023    | 0.11023    | 0.11023    |   0.0 |  0.06
Output  | 0.00018536 | 0.00018536 | 0.00018536 |   0.0 |  0.00
Modify  | 0.70795    | 0.70795    | 0.70795    |   0.0 |  0.35
Other   |            | 0.09436    |            |       |  0.05

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

Total # of neighbors = 215114
Ave neighs/atom = 53.7785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.390298023282, Press = -0.0963193310412686
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   
     75000  -13208.92      -13208.92      -13339.93      -13339.93       253.44691      253.44691      67462.427      67462.427      374.65936      374.65936    
     76000  -13213.029     -13213.029     -13342.715     -13342.715      250.88482      250.88482      67452.246      67452.246      473.11821      473.11821    
Loop time of 199.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.529 hours/ns, 5.002 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    | 198.99     | 198.99     | 198.99     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11179    | 0.11179    | 0.11179    |   0.0 |  0.06
Output  | 0.00018642 | 0.00018642 | 0.00018642 |   0.0 |  0.00
Modify  | 0.71163    | 0.71163    | 0.71163    |   0.0 |  0.36
Other   |            | 0.09532    |            |       |  0.05

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

Total # of neighbors = 215096
Ave neighs/atom = 53.774
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.381020037714, Press = 0.595803526859442
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   
     76000  -13213.029     -13213.029     -13342.715     -13342.715      250.88482      250.88482      67452.246      67452.246      473.11821      473.11821    
     77000  -13209.989     -13209.989     -13338.635     -13338.635      248.87299      248.87299      67548.908      67548.908     -581.48341     -581.48341    
Loop time of 200.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.656 hours/ns, 4.991 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    | 199.44     | 199.44     | 199.44     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11159    | 0.11159    | 0.11159    |   0.0 |  0.06
Output  | 0.00024187 | 0.00024187 | 0.00024187 |   0.0 |  0.00
Modify  | 0.71311    | 0.71311    | 0.71311    |   0.0 |  0.36
Other   |            | 0.09577    |            |       |  0.05

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

Total # of neighbors = 215216
Ave neighs/atom = 53.804
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.350926819886, Press = -0.0332655871459353
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   
     77000  -13209.989     -13209.989     -13338.635     -13338.635      248.87299      248.87299      67548.908      67548.908     -581.48341     -581.48341    
     78000  -13205.532     -13205.532     -13337.071     -13337.071      254.47107      254.47107      67475.382      67475.382      471.00434      471.00434    
Loop time of 199.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.282 hours/ns, 5.025 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    | 198.1      | 198.1      | 198.1      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10989    | 0.10989    | 0.10989    |   0.0 |  0.06
Output  | 0.00018692 | 0.00018692 | 0.00018692 |   0.0 |  0.00
Modify  | 0.70752    | 0.70752    | 0.70752    |   0.0 |  0.36
Other   |            | 0.09471    |            |       |  0.05

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

Total # of neighbors = 215100
Ave neighs/atom = 53.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
67497.345330964

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0