# 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.9497474655508995*${_u_distance}
variable latticeconst_converted equal 4.9497474655508995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.9497474655509
Lattice spacing in x,y,z = 4.9497475 4.9497475 4.9497475
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (49.497475 49.497475 49.497475)
  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 (49.497475 49.497475 49.497475)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Pb

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

kim interactions Pb
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Pb__MO_019208265157_001
pair_coeff * * Pb
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 207.2

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.236 | 4.236 | 4.236 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8008.4674     -8008.4674     -8160          -8160           293.15         293.15         121268.81      121268.81      1334.677       1334.677     
      1000  -7834.2109     -7834.2109     -7995.9777     -7995.9777      312.94893      312.94893      124266.03      124266.03      486.15971      486.15971    
Loop time of 283.56 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.767 hours/ns, 3.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.45     | 282.45     | 282.45     |   0.0 | 99.61
Neigh   | 0.12498    | 0.12498    | 0.12498    |   0.0 |  0.04
Comm    | 0.14648    | 0.14648    | 0.14648    |   0.0 |  0.05
Output  | 0.00030282 | 0.00030282 | 0.00030282 |   0.0 |  0.00
Modify  | 0.73512    | 0.73512    | 0.73512    |   0.0 |  0.26
Other   |            | 0.1001     |            |       |  0.04

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

Total # of neighbors = 218186
Ave neighs/atom = 54.5465
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -7834.2109     -7834.2109     -7995.9777     -7995.9777      312.94893      312.94893      124266.03      124266.03      486.15971      486.15971    
      2000  -7847.4057     -7847.4057     -7999.0762     -7999.0762      293.41676      293.41676      124430.95      124430.95     -272.61392     -272.61392    
Loop time of 283.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.749 hours/ns, 3.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.4      | 282.4      | 282.4      |   0.0 | 99.61
Neigh   | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.04
Comm    | 0.13731    | 0.13731    | 0.13731    |   0.0 |  0.05
Output  | 0.00023445 | 0.00023445 | 0.00023445 |   0.0 |  0.00
Modify  | 0.73405    | 0.73405    | 0.73405    |   0.0 |  0.26
Other   |            | 0.09933    |            |       |  0.04

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

Total # of neighbors = 218194
Ave neighs/atom = 54.5485
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -7847.4057     -7847.4057     -7999.0762     -7999.0762      293.41676      293.41676      124430.95      124430.95     -272.61392     -272.61392    
      3000  -7842.0605     -7842.0605     -7994.7237     -7994.7237      295.33734      295.33734      124462.13      124462.13     -43.842644     -43.842644    
Loop time of 262.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.932 hours/ns, 3.809 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.57     | 261.57     | 261.57     |   0.0 | 99.63
Neigh   | 0.11814    | 0.11814    | 0.11814    |   0.0 |  0.04
Comm    | 0.13004    | 0.13004    | 0.13004    |   0.0 |  0.05
Output  | 0.00023678 | 0.00023678 | 0.00023678 |   0.0 |  0.00
Modify  | 0.64477    | 0.64477    | 0.64477    |   0.0 |  0.25
Other   |            | 0.0912     |            |       |  0.03

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

Total # of neighbors = 218208
Ave neighs/atom = 54.552
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -7842.0605     -7842.0605     -7994.7237     -7994.7237      295.33734      295.33734      124462.13      124462.13     -43.842644     -43.842644    
      4000  -7849.587      -7849.587      -7998.0781     -7998.0781      287.26618      287.26618      124429.88      124429.88     -170.41177     -170.41177    
Loop time of 263.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.108 hours/ns, 3.800 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.2      | 262.2      | 262.2      |   0.0 | 99.63
Neigh   | 0.1184     | 0.1184     | 0.1184     |   0.0 |  0.04
Comm    | 0.13061    | 0.13061    | 0.13061    |   0.0 |  0.05
Output  | 0.00023822 | 0.00023822 | 0.00023822 |   0.0 |  0.00
Modify  | 0.64406    | 0.64406    | 0.64406    |   0.0 |  0.24
Other   |            | 0.0913     |            |       |  0.03

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

Total # of neighbors = 218078
Ave neighs/atom = 54.5195
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -7849.587      -7849.587      -7998.0781     -7998.0781      287.26618      287.26618      124429.88      124429.88     -170.41177     -170.41177    
      5000  -7843.1528     -7843.1528     -7998.9826     -7998.9826      301.46333      301.46333      124416.19      124416.19     -111.11069     -111.11069    
Loop time of 262.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.925 hours/ns, 3.809 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.54     | 261.54     | 261.54     |   0.0 | 99.62
Neigh   | 0.11833    | 0.11833    | 0.11833    |   0.0 |  0.05
Comm    | 0.12952    | 0.12952    | 0.12952    |   0.0 |  0.05
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.65052    | 0.65052    | 0.65052    |   0.0 |  0.25
Other   |            | 0.09147    |            |       |  0.03

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

Total # of neighbors = 218140
Ave neighs/atom = 54.535
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 300.69946894925, Press = 72.8617384834122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -7843.1528     -7843.1528     -7998.9826     -7998.9826      301.46333      301.46333      124416.19      124416.19     -111.11069     -111.11069    
      6000  -7853.5522     -7853.5522     -8004.4609     -8004.4609      291.94319      291.94319      124334.85      124334.85     -225.83008     -225.83008    
Loop time of 263.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.287 hours/ns, 3.790 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.82     | 262.82     | 262.82     |   0.0 | 99.62
Neigh   | 0.11851    | 0.11851    | 0.11851    |   0.0 |  0.04
Comm    | 0.13178    | 0.13178    | 0.13178    |   0.0 |  0.05
Output  | 0.00019324 | 0.00019324 | 0.00019324 |   0.0 |  0.00
Modify  | 0.67223    | 0.67223    | 0.67223    |   0.0 |  0.25
Other   |            | 0.09175    |            |       |  0.03

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

Total # of neighbors = 217840
Ave neighs/atom = 54.46
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.87234110704, Press = -1.61603788269757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -7853.5522     -7853.5522     -8004.4609     -8004.4609      291.94319      291.94319      124334.85      124334.85     -225.83008     -225.83008    
      7000  -7851.0608     -7851.0608     -8002.4238     -8002.4238      292.82211      292.82211      124270.83      124270.83      121.84812      121.84812    
Loop time of 262.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 73.048 hours/ns, 3.803 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.96     | 261.96     | 261.96     |   0.0 | 99.62
Neigh   | 0.11796    | 0.11796    | 0.11796    |   0.0 |  0.04
Comm    | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.05
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.67166    | 0.67166    | 0.67166    |   0.0 |  0.26
Other   |            | 0.09171    |            |       |  0.03

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

Total # of neighbors = 218070
Ave neighs/atom = 54.5175
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.339432749412, Press = -2.13528093898667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -7851.0608     -7851.0608     -8002.4238     -8002.4238      292.82211      292.82211      124270.83      124270.83      121.84812      121.84812    
      8000  -7850.3042     -7850.3042     -8001.8517     -8001.8517      293.17889      293.17889      124331.95      124331.95     -52.199039     -52.199039    
Loop time of 262.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.953 hours/ns, 3.808 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.62     | 261.62     | 261.62     |   0.0 | 99.61
Neigh   | 0.11841    | 0.11841    | 0.11841    |   0.0 |  0.05
Comm    | 0.13065    | 0.13065    | 0.13065    |   0.0 |  0.05
Output  | 0.00019354 | 0.00019354 | 0.00019354 |   0.0 |  0.00
Modify  | 0.67296    | 0.67296    | 0.67296    |   0.0 |  0.26
Other   |            | 0.09096    |            |       |  0.03

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

Total # of neighbors = 217908
Ave neighs/atom = 54.477
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.313105478061, Press = 4.70058629581788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -7850.3042     -7850.3042     -8001.8517     -8001.8517      293.17889      293.17889      124331.95      124331.95     -52.199039     -52.199039    
      9000  -7853.3873     -7853.3873     -8003.1638     -8003.1638      289.75265      289.75265      124289.43      124289.43      18.621054      18.621054    
Loop time of 263.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.175 hours/ns, 3.796 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.42     | 262.42     | 262.42     |   0.0 | 99.62
Neigh   | 0.11836    | 0.11836    | 0.11836    |   0.0 |  0.04
Comm    | 0.13058    | 0.13058    | 0.13058    |   0.0 |  0.05
Output  | 0.00023475 | 0.00023475 | 0.00023475 |   0.0 |  0.00
Modify  | 0.67303    | 0.67303    | 0.67303    |   0.0 |  0.26
Other   |            | 0.09111    |            |       |  0.03

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

Total # of neighbors = 217902
Ave neighs/atom = 54.4755
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.22255551213, Press = 2.6799551091897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -7853.3873     -7853.3873     -8003.1638     -8003.1638      289.75265      289.75265      124289.43      124289.43      18.621054      18.621054    
     10000  -7848.5634     -7848.5634     -8000.5827     -8000.5827      294.0916       294.0916       124332.38      124332.38      12.230859      12.230859    
Loop time of 262.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.974 hours/ns, 3.807 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.7      | 261.7      | 261.7      |   0.0 | 99.62
Neigh   | 0.11818    | 0.11818    | 0.11818    |   0.0 |  0.04
Comm    | 0.12962    | 0.12962    | 0.12962    |   0.0 |  0.05
Output  | 0.00019311 | 0.00019311 | 0.00019311 |   0.0 |  0.00
Modify  | 0.66988    | 0.66988    | 0.66988    |   0.0 |  0.25
Other   |            | 0.09079    |            |       |  0.03

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

Total # of neighbors = 218098
Ave neighs/atom = 54.5245
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.055718669208, Press = 3.77695052790992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -7848.5634     -7848.5634     -8000.5827     -8000.5827      294.0916       294.0916       124332.38      124332.38      12.230859      12.230859    
     11000  -7855.0483     -7855.0483     -8003.4837     -8003.4837      287.1583       287.1583       124516.89      124516.89     -876.94622     -876.94622    
Loop time of 263.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.189 hours/ns, 3.795 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.47     | 262.47     | 262.47     |   0.0 | 99.62
Neigh   | 0.11796    | 0.11796    | 0.11796    |   0.0 |  0.04
Comm    | 0.13112    | 0.13112    | 0.13112    |   0.0 |  0.05
Output  | 0.00019492 | 0.00019492 | 0.00019492 |   0.0 |  0.00
Modify  | 0.67005    | 0.67005    | 0.67005    |   0.0 |  0.25
Other   |            | 0.09078    |            |       |  0.03

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

Total # of neighbors = 217844
Ave neighs/atom = 54.461
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.03315471194, Press = 1.49145888715327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -7855.0483     -7855.0483     -8003.4837     -8003.4837      287.1583       287.1583       124516.89      124516.89     -876.94622     -876.94622    
     12000  -7848.1463     -7848.1463     -7998.8444     -7998.8444      291.53557      291.53557      124364.33      124364.33      14.385976      14.385976    
Loop time of 262.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.971 hours/ns, 3.807 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.65     | 261.65     | 261.65     |   0.0 | 99.60
Neigh   | 0.15738    | 0.15738    | 0.15738    |   0.0 |  0.06
Comm    | 0.12905    | 0.12905    | 0.12905    |   0.0 |  0.05
Output  | 0.0002394  | 0.0002394  | 0.0002394  |   0.0 |  0.00
Modify  | 0.67184    | 0.67184    | 0.67184    |   0.0 |  0.26
Other   |            | 0.09134    |            |       |  0.03

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

Total # of neighbors = 217950
Ave neighs/atom = 54.4875
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.956799651634, Press = -1.07652414913962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -7848.1463     -7848.1463     -7998.8444     -7998.8444      291.53557      291.53557      124364.33      124364.33      14.385976      14.385976    
     13000  -7851.4487     -7851.4487     -8001.7026     -8001.7026      290.67632      290.67632      124213.39      124213.39      402.55999      402.55999    
Loop time of 262.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.968 hours/ns, 3.807 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.67     | 261.67     | 261.67     |   0.0 | 99.61
Neigh   | 0.1184     | 0.1184     | 0.1184     |   0.0 |  0.05
Comm    | 0.13048    | 0.13048    | 0.13048    |   0.0 |  0.05
Output  | 0.00019489 | 0.00019489 | 0.00019489 |   0.0 |  0.00
Modify  | 0.67129    | 0.67129    | 0.67129    |   0.0 |  0.26
Other   |            | 0.09108    |            |       |  0.03

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

Total # of neighbors = 218030
Ave neighs/atom = 54.5075
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.034925489506, Press = 1.31523097614957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -7851.4487     -7851.4487     -8001.7026     -8001.7026      290.67632      290.67632      124213.39      124213.39      402.55999      402.55999    
     14000  -7847.4174     -7847.4174     -8000.7389     -8000.7389      296.61086      296.61086      124470.79      124470.79     -456.19611     -456.19611    
Loop time of 263.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.197 hours/ns, 3.795 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.5      | 262.5      | 262.5      |   0.0 | 99.62
Neigh   | 0.11851    | 0.11851    | 0.11851    |   0.0 |  0.04
Comm    | 0.13053    | 0.13053    | 0.13053    |   0.0 |  0.05
Output  | 0.00018665 | 0.00018665 | 0.00018665 |   0.0 |  0.00
Modify  | 0.67029    | 0.67029    | 0.67029    |   0.0 |  0.25
Other   |            | 0.091      |            |       |  0.03

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

Total # of neighbors = 217762
Ave neighs/atom = 54.4405
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925019279242, Press = 0.849007877291305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -7847.4174     -7847.4174     -8000.7389     -8000.7389      296.61086      296.61086      124470.79      124470.79     -456.19611     -456.19611    
     15000  -7849.9025     -7849.9025     -8001.3654     -8001.3654      293.01527      293.01527      124315.61      124315.61      20.266408      20.266408    
Loop time of 261.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.330 ns/day, 72.722 hours/ns, 3.820 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.75     | 260.75     | 260.75     |   0.0 | 99.60
Neigh   | 0.1571     | 0.1571     | 0.1571     |   0.0 |  0.06
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.05
Output  | 0.00019353 | 0.00019353 | 0.00019353 |   0.0 |  0.00
Modify  | 0.66592    | 0.66592    | 0.66592    |   0.0 |  0.25
Other   |            | 0.09347    |            |       |  0.04

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

Total # of neighbors = 218054
Ave neighs/atom = 54.5135
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.982750690835, Press = -1.10952239787168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -7849.9025     -7849.9025     -8001.3654     -8001.3654      293.01527      293.01527      124315.61      124315.61      20.266408      20.266408    
     16000  -7844.9406     -7844.9406     -8000.468      -8000.468       300.87813      300.87813      124224.3       124224.3       458.37316      458.37316    
Loop time of 263.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.067 hours/ns, 3.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.99     | 261.99     | 261.99     |   0.0 | 99.60
Neigh   | 0.15755    | 0.15755    | 0.15755    |   0.0 |  0.06
Comm    | 0.13094    | 0.13094    | 0.13094    |   0.0 |  0.05
Output  | 0.00023467 | 0.00023467 | 0.00023467 |   0.0 |  0.00
Modify  | 0.66913    | 0.66913    | 0.66913    |   0.0 |  0.25
Other   |            | 0.09256    |            |       |  0.04

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

Total # of neighbors = 218124
Ave neighs/atom = 54.531
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.035165531734, Press = 0.6455891844296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -7844.9406     -7844.9406     -8000.468      -8000.468       300.87813      300.87813      124224.3       124224.3       458.37316      458.37316    
     17000  -7856.2211     -7856.2211     -8003.5073     -8003.5073      284.9351       284.9351       124247.73      124247.73      108.17295      108.17295    
Loop time of 263.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.262 hours/ns, 3.792 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.73     | 262.73     | 262.73     |   0.0 | 99.62
Neigh   | 0.11819    | 0.11819    | 0.11819    |   0.0 |  0.04
Comm    | 0.12883    | 0.12883    | 0.12883    |   0.0 |  0.05
Output  | 0.00022755 | 0.00022755 | 0.00022755 |   0.0 |  0.00
Modify  | 0.67136    | 0.67136    | 0.67136    |   0.0 |  0.25
Other   |            | 0.09181    |            |       |  0.03

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

Total # of neighbors = 217836
Ave neighs/atom = 54.459
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.951406083474, Press = 1.59096208048836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -7856.2211     -7856.2211     -8003.5073     -8003.5073      284.9351       284.9351       124247.73      124247.73      108.17295      108.17295    
     18000  -7850.5558     -7850.5558     -8000.6518     -8000.6518      290.37081      290.37081      124459.98      124459.98     -431.7096      -431.7096     
Loop time of 262.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.945 hours/ns, 3.808 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.59     | 261.59     | 261.59     |   0.0 | 99.61
Neigh   | 0.11829    | 0.11829    | 0.11829    |   0.0 |  0.05
Comm    | 0.1301     | 0.1301     | 0.1301     |   0.0 |  0.05
Output  | 0.00019502 | 0.00019502 | 0.00019502 |   0.0 |  0.00
Modify  | 0.67061    | 0.67061    | 0.67061    |   0.0 |  0.26
Other   |            | 0.09252    |            |       |  0.04

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

Total # of neighbors = 218222
Ave neighs/atom = 54.5555
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.953199398192, Press = 1.31076758378419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -7850.5558     -7850.5558     -8000.6518     -8000.6518      290.37081      290.37081      124459.98      124459.98     -431.7096      -431.7096     
     19000  -7853.229      -7853.229      -8003.8827     -8003.8827      291.44976      291.44976      124306.97      124306.97     -67.445172     -67.445172    
Loop time of 263.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.070 hours/ns, 3.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.04     | 262.04     | 262.04     |   0.0 | 99.62
Neigh   | 0.11797    | 0.11797    | 0.11797    |   0.0 |  0.04
Comm    | 0.12905    | 0.12905    | 0.12905    |   0.0 |  0.05
Output  | 0.00019301 | 0.00019301 | 0.00019301 |   0.0 |  0.00
Modify  | 0.67329    | 0.67329    | 0.67329    |   0.0 |  0.26
Other   |            | 0.0917     |            |       |  0.03

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

Total # of neighbors = 217904
Ave neighs/atom = 54.476
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.93723306682, Press = -0.395273002158138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -7853.229      -7853.229      -8003.8827     -8003.8827      291.44976      291.44976      124306.97      124306.97     -67.445172     -67.445172    
     20000  -7844.7995     -7844.7995     -7999.4725     -7999.4725      299.22542      299.22542      124313         124313         220.98272      220.98272    
Loop time of 263.606 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.224 hours/ns, 3.794 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.59     | 262.59     | 262.59     |   0.0 | 99.62
Neigh   | 0.11822    | 0.11822    | 0.11822    |   0.0 |  0.04
Comm    | 0.13088    | 0.13088    | 0.13088    |   0.0 |  0.05
Output  | 0.00023818 | 0.00023818 | 0.00023818 |   0.0 |  0.00
Modify  | 0.67028    | 0.67028    | 0.67028    |   0.0 |  0.25
Other   |            | 0.09179    |            |       |  0.03

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

Total # of neighbors = 217810
Ave neighs/atom = 54.4525
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.976005525375, Press = 0.279338644275738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -7844.7995     -7844.7995     -7999.4725     -7999.4725      299.22542      299.22542      124313         124313         220.98272      220.98272    
     21000  -7852.42       -7852.42       -8002.2661     -8002.2661      289.88759      289.88759      124277.57      124277.57      105.00544      105.00544    
Loop time of 262.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.871 hours/ns, 3.812 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.32     | 261.32     | 261.32     |   0.0 | 99.61
Neigh   | 0.11808    | 0.11808    | 0.11808    |   0.0 |  0.05
Comm    | 0.13187    | 0.13187    | 0.13187    |   0.0 |  0.05
Output  | 0.00019419 | 0.00019419 | 0.00019419 |   0.0 |  0.00
Modify  | 0.67054    | 0.67054    | 0.67054    |   0.0 |  0.26
Other   |            | 0.09207    |            |       |  0.04

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

Total # of neighbors = 217914
Ave neighs/atom = 54.4785
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.057644021955, Press = 1.06873105025547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -7852.42       -7852.42       -8002.2661     -8002.2661      289.88759      289.88759      124277.57      124277.57      105.00544      105.00544    
     22000  -7853.4764     -7853.4764     -8001.3571     -8001.3571      286.0852       286.0852       124482.05      124482.05     -574.59569     -574.59569    
Loop time of 263.238 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.122 hours/ns, 3.799 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.22     | 262.22     | 262.22     |   0.0 | 99.61
Neigh   | 0.11821    | 0.11821    | 0.11821    |   0.0 |  0.04
Comm    | 0.13152    | 0.13152    | 0.13152    |   0.0 |  0.05
Output  | 0.00023303 | 0.00023303 | 0.00023303 |   0.0 |  0.00
Modify  | 0.67218    | 0.67218    | 0.67218    |   0.0 |  0.26
Other   |            | 0.09158    |            |       |  0.03

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

Total # of neighbors = 217928
Ave neighs/atom = 54.482
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.066014321042, Press = 0.252990743280143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -7853.4764     -7853.4764     -8001.3571     -8001.3571      286.0852       286.0852       124482.05      124482.05     -574.59569     -574.59569    
     23000  -7845.5871     -7845.5871     -7996.1397     -7996.1397      291.25419      291.25419      124520.37      124520.37     -345.29198     -345.29198    
Loop time of 263.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.256 hours/ns, 3.792 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.71     | 262.71     | 262.71     |   0.0 | 99.62
Neigh   | 0.1183     | 0.1183     | 0.1183     |   0.0 |  0.04
Comm    | 0.13072    | 0.13072    | 0.13072    |   0.0 |  0.05
Output  | 0.00019488 | 0.00019488 | 0.00019488 |   0.0 |  0.00
Modify  | 0.67225    | 0.67225    | 0.67225    |   0.0 |  0.25
Other   |            | 0.09175    |            |       |  0.03

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

Total # of neighbors = 217894
Ave neighs/atom = 54.4735
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.092602083946, Press = -1.17858101696546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -7845.5871     -7845.5871     -7996.1397     -7996.1397      291.25419      291.25419      124520.37      124520.37     -345.29198     -345.29198    
     24000  -7848.4546     -7848.4546     -7999.9211     -7999.9211      293.0221       293.0221       124220         124220         495.25508      495.25508    
Loop time of 263.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.236 hours/ns, 3.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.63     | 262.63     | 262.63     |   0.0 | 99.61
Neigh   | 0.1183     | 0.1183     | 0.1183     |   0.0 |  0.04
Comm    | 0.13091    | 0.13091    | 0.13091    |   0.0 |  0.05
Output  | 0.00019597 | 0.00019597 | 0.00019597 |   0.0 |  0.00
Modify  | 0.6738     | 0.6738     | 0.6738     |   0.0 |  0.26
Other   |            | 0.09202    |            |       |  0.03

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0