# 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.0000000 0.0000000 0.0000000) 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.0000000 0.0000000 0.0000000) to (49.497475 49.497475 49.497475)
  create_atoms CPU = 0.001 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_000
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 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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    -7987.791    -7987.791        -8160        -8160       333.15       333.15    121268.81    121268.81    1516.7921    1516.7921 
    1000   -7787.2804   -7787.2804    -7968.686    -7968.686    350.94147    350.94147    124886.58    124886.58    81.448528    81.448528 
Loop time of 106.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.811 ns/day, 29.586 hours/ns, 9.389 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    | 106.03     | 106.03     | 106.03     |   0.0 | 99.55
Neigh   | 0.075407   | 0.075407   | 0.075407   |   0.0 |  0.07
Comm    | 0.049779   | 0.049779   | 0.049779   |   0.0 |  0.05
Output  | 0.00027473 | 0.00027473 | 0.00027473 |   0.0 |  0.00
Modify  | 0.30735    | 0.30735    | 0.30735    |   0.0 |  0.29
Other   |            | 0.04758    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4870.00 ave        4870 max        4870 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218350.0 ave      218350 max      218350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218350
Ave neighs/atom = 54.587500
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
    1000   -7787.2804   -7787.2804    -7968.686    -7968.686    350.94147    350.94147    124886.58    124886.58    81.448528    81.448528 
    2000   -7803.3843   -7803.3843    -7974.853    -7974.853     331.7178     331.7178     124892.2     124892.2   -282.73676   -282.73676 
Loop time of 104.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.913 hours/ns, 9.607 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    | 103.6      | 103.6      | 103.6      |   0.0 | 99.53
Neigh   | 0.076256   | 0.076256   | 0.076256   |   0.0 |  0.07
Comm    | 0.048238   | 0.048238   | 0.048238   |   0.0 |  0.05
Output  | 0.00013927 | 0.00013927 | 0.00013927 |   0.0 |  0.00
Modify  | 0.30875    | 0.30875    | 0.30875    |   0.0 |  0.30
Other   |            | 0.05148    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4771.00 ave        4771 max        4771 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218468.0 ave      218468 max      218468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218468
Ave neighs/atom = 54.617000
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7803.3843   -7803.3843    -7974.853    -7974.853     331.7178     331.7178     124892.2     124892.2   -282.73676   -282.73676 
    3000   -7799.9548   -7799.9548   -7971.9465   -7971.9465    332.72944    332.72944    124919.75    124919.75   -143.55108   -143.55108 
Loop time of 103.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.803 hours/ns, 9.644 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    | 103.22     | 103.22     | 103.22     |   0.0 | 99.54
Neigh   | 0.075824   | 0.075824   | 0.075824   |   0.0 |  0.07
Comm    | 0.04724    | 0.04724    | 0.04724    |   0.0 |  0.05
Output  | 0.00025541 | 0.00025541 | 0.00025541 |   0.0 |  0.00
Modify  | 0.30212    | 0.30212    | 0.30212    |   0.0 |  0.29
Other   |            | 0.04836    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4827.00 ave        4827 max        4827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218294.0 ave      218294 max      218294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218294
Ave neighs/atom = 54.573500
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7799.9548   -7799.9548   -7971.9465   -7971.9465    332.72944    332.72944    124919.75    124919.75   -143.55108   -143.55108 
    4000   -7805.4482   -7805.4482   -7975.4703   -7975.4703    328.91917    328.91917     124808.8     124808.8     48.41283     48.41283 
Loop time of 103.881 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.832 ns/day, 28.856 hours/ns, 9.626 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    | 103.41     | 103.41     | 103.41     |   0.0 | 99.54
Neigh   | 0.076142   | 0.076142   | 0.076142   |   0.0 |  0.07
Comm    | 0.047398   | 0.047398   | 0.047398   |   0.0 |  0.05
Output  | 0.00013646 | 0.00013646 | 0.00013646 |   0.0 |  0.00
Modify  | 0.30154    | 0.30154    | 0.30154    |   0.0 |  0.29
Other   |            | 0.04837    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4821.00 ave        4821 max        4821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218290.0 ave      218290 max      218290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218290
Ave neighs/atom = 54.572500
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7805.4482   -7805.4482   -7975.4703   -7975.4703    328.91917    328.91917     124808.8     124808.8     48.41283     48.41283 
    5000   -7798.0796   -7798.0796   -7974.5689   -7974.5689    341.43057    341.43057    124721.95    124721.95    456.85924    456.85924 
Loop time of 103.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.697 hours/ns, 9.680 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    | 102.84     | 102.84     | 102.84     |   0.0 | 99.55
Neigh   | 0.075843   | 0.075843   | 0.075843   |   0.0 |  0.07
Comm    | 0.046166   | 0.046166   | 0.046166   |   0.0 |  0.04
Output  | 0.00011339 | 0.00011339 | 0.00011339 |   0.0 |  0.00
Modify  | 0.29831    | 0.29831    | 0.29831    |   0.0 |  0.29
Other   |            | 0.04489    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4798.00 ave        4798 max        4798 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218250.0 ave      218250 max      218250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218250
Ave neighs/atom = 54.562500
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 = 339.60906300736, Press = -155.494257284713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7798.0796   -7798.0796   -7974.5689   -7974.5689    341.43057    341.43057    124721.95    124721.95    456.85924    456.85924 
    6000   -7809.5326   -7809.5326    -7982.018    -7982.018    333.68484    333.68484    124721.12    124721.12   -38.434259   -38.434259 
Loop time of 103.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.822 hours/ns, 9.638 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    | 103.29     | 103.29     | 103.29     |   0.0 | 99.54
Neigh   | 0.075454   | 0.075454   | 0.075454   |   0.0 |  0.07
Comm    | 0.046542   | 0.046542   | 0.046542   |   0.0 |  0.04
Output  | 0.00010508 | 0.00010508 | 0.00010508 |   0.0 |  0.00
Modify  | 0.30647    | 0.30647    | 0.30647    |   0.0 |  0.30
Other   |            | 0.04474    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4875.00 ave        4875 max        4875 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      217962.0 ave      217962 max      217962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217962
Ave neighs/atom = 54.490500
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 = 333.784671814463, Press = -14.4649978848964
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7809.5326   -7809.5326    -7982.018    -7982.018    333.68484    333.68484    124721.12    124721.12   -38.434259   -38.434259 
    7000   -7808.5834   -7808.5834   -7979.2407   -7979.2407      330.148      330.148    124791.21    124791.21   -175.12318   -175.12318 
Loop time of 103.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.687 hours/ns, 9.683 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    | 102.8      | 102.8      | 102.8      |   0.0 | 99.54
Neigh   | 0.07568    | 0.07568    | 0.07568    |   0.0 |  0.07
Comm    | 0.046215   | 0.046215   | 0.046215   |   0.0 |  0.04
Output  | 0.00010757 | 0.00010757 | 0.00010757 |   0.0 |  0.00
Modify  | 0.30603    | 0.30603    | 0.30603    |   0.0 |  0.30
Other   |            | 0.04496    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4784.00 ave        4784 max        4784 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218384.0 ave      218384 max      218384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218384
Ave neighs/atom = 54.596000
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 = 333.337596021426, Press = -1.17580752111621
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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.227 | 4.227 | 4.227 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7808.5834   -7808.5834   -7979.2407   -7979.2407      330.148      330.148    124791.21    124791.21   -175.12318   -175.12318 
    8000   -7807.6325   -7807.6325   -7980.9158   -7980.9158    335.22829    335.22829    124538.62    124538.62    670.49466    670.49466 
Loop time of 103.239 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.677 hours/ns, 9.686 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    | 102.76     | 102.76     | 102.76     |   0.0 | 99.53
Neigh   | 0.0756     | 0.0756     | 0.0756     |   0.0 |  0.07
Comm    | 0.047119   | 0.047119   | 0.047119   |   0.0 |  0.05
Output  | 0.00010375 | 0.00010375 | 0.00010375 |   0.0 |  0.00
Modify  | 0.31099    | 0.31099    | 0.31099    |   0.0 |  0.30
Other   |            | 0.04761    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4877.00 ave        4877 max        4877 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218272.0 ave      218272 max      218272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218272
Ave neighs/atom = 54.568000
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 = 333.274601555183, Press = 0.547548313420132
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7807.6325   -7807.6325   -7980.9158   -7980.9158    335.22829    335.22829    124538.62    124538.62    670.49466    670.49466 
    9000   -7811.1847   -7811.1847   -7983.3186   -7983.3186    333.00456    333.00456    124649.53    124649.53    161.77861    161.77861 
Loop time of 103.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.806 hours/ns, 9.643 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    | 103.22     | 103.22     | 103.22     |   0.0 | 99.54
Neigh   | 0.075225   | 0.075225   | 0.075225   |   0.0 |  0.07
Comm    | 0.047265   | 0.047265   | 0.047265   |   0.0 |  0.05
Output  | 8.1343e-05 | 8.1343e-05 | 8.1343e-05 |   0.0 |  0.00
Modify  | 0.30956    | 0.30956    | 0.30956    |   0.0 |  0.30
Other   |            | 0.04673    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4847.00 ave        4847 max        4847 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218260.0 ave      218260 max      218260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218260
Ave neighs/atom = 54.565000
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 = 333.19548946372, Press = -3.18297613184598
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7811.1847   -7811.1847   -7983.3186   -7983.3186    333.00456    333.00456    124649.53    124649.53    161.77861    161.77861 
   10000   -7803.7227   -7803.7227   -7979.8202   -7979.8202    340.67253    340.67253       124771       124771   -57.408699   -57.408699 
Loop time of 102.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.842 ns/day, 28.506 hours/ns, 9.745 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    | 102.17     | 102.17     | 102.17     |   0.0 | 99.56
Neigh   | 0.05616    | 0.05616    | 0.05616    |   0.0 |  0.05
Comm    | 0.045004   | 0.045004   | 0.045004   |   0.0 |  0.04
Output  | 0.00010143 | 0.00010143 | 0.00010143 |   0.0 |  0.00
Modify  | 0.30308    | 0.30308    | 0.30308    |   0.0 |  0.30
Other   |            | 0.0437     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4835.00 ave        4835 max        4835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218298.0 ave      218298 max      218298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218298
Ave neighs/atom = 54.574500
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 = 333.583078451449, Press = -3.69659247326494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7803.7227   -7803.7227   -7979.8202   -7979.8202    340.67253    340.67253       124771       124771   -57.408699   -57.408699 
   11000   -7801.0628   -7801.0628   -7981.6057   -7981.6057    349.27256    349.27256    124813.57    124813.57   -379.84775   -379.84775 
Loop time of 102.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.841 ns/day, 28.538 hours/ns, 9.734 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    | 102.27     | 102.27     | 102.27     |   0.0 | 99.55
Neigh   | 0.075728   | 0.075728   | 0.075728   |   0.0 |  0.07
Comm    | 0.045315   | 0.045315   | 0.045315   |   0.0 |  0.04
Output  | 0.00010807 | 0.00010807 | 0.00010807 |   0.0 |  0.00
Modify  | 0.30252    | 0.30252    | 0.30252    |   0.0 |  0.29
Other   |            | 0.04335    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4763.00 ave        4763 max        4763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218132.0 ave      218132 max      218132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218132
Ave neighs/atom = 54.533000
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 = 333.66667627679, Press = -8.507156495
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7801.0628   -7801.0628   -7981.6057   -7981.6057    349.27256    349.27256    124813.57    124813.57   -379.84775   -379.84775 
   12000   -7804.9552   -7804.9552   -7977.3813   -7977.3813    333.56993    333.56993    124900.39    124900.39   -409.49277   -409.49277 
Loop time of 102.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.840 ns/day, 28.567 hours/ns, 9.724 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    | 102.37     | 102.37     | 102.37     |   0.0 | 99.54
Neigh   | 0.075358   | 0.075358   | 0.075358   |   0.0 |  0.07
Comm    | 0.045341   | 0.045341   | 0.045341   |   0.0 |  0.04
Output  | 0.00010004 | 0.00010004 | 0.00010004 |   0.0 |  0.00
Modify  | 0.30471    | 0.30471    | 0.30471    |   0.0 |  0.30
Other   |            | 0.04488    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4779.00 ave        4779 max        4779 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218380.0 ave      218380 max      218380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218380
Ave neighs/atom = 54.595000
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 = 333.83575962876, Press = -2.49130282151446
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7804.9552   -7804.9552   -7977.3813   -7977.3813    333.56993    333.56993    124900.39    124900.39   -409.49277   -409.49277 
   13000   -7804.1457   -7804.1457   -7978.1375   -7978.1375     336.5989     336.5989    124801.27    124801.27   -139.08283   -139.08283 
Loop time of 102.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.841 ns/day, 28.539 hours/ns, 9.733 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    | 102.28     | 102.28     | 102.28     |   0.0 | 99.56
Neigh   | 0.056594   | 0.056594   | 0.056594   |   0.0 |  0.06
Comm    | 0.045921   | 0.045921   | 0.045921   |   0.0 |  0.04
Output  | 9.5844e-05 | 9.5844e-05 | 9.5844e-05 |   0.0 |  0.00
Modify  | 0.30599    | 0.30599    | 0.30599    |   0.0 |  0.30
Other   |            | 0.0461     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4867.00 ave        4867 max        4867 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218296.0 ave      218296 max      218296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218296
Ave neighs/atom = 54.574000
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 = 333.750719338408, Press = -1.29322121538055
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7804.1457   -7804.1457   -7978.1375   -7978.1375     336.5989     336.5989    124801.27    124801.27   -139.08283   -139.08283 
   14000    -7801.073    -7801.073   -7976.2839   -7976.2839    338.95726    338.95726    124766.53    124766.53    179.98031    179.98031 
Loop time of 101.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.848 ns/day, 28.292 hours/ns, 9.818 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    | 101.38     | 101.38     | 101.38     |   0.0 | 99.54
Neigh   | 0.075014   | 0.075014   | 0.075014   |   0.0 |  0.07
Comm    | 0.045345   | 0.045345   | 0.045345   |   0.0 |  0.04
Output  | 0.00010016 | 0.00010016 | 0.00010016 |   0.0 |  0.00
Modify  | 0.30307    | 0.30307    | 0.30307    |   0.0 |  0.30
Other   |            | 0.04558    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4765.00 ave        4765 max        4765 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218186.0 ave      218186 max      218186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218186
Ave neighs/atom = 54.546500
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 = 333.831502339839, Press = -1.27246655597901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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.227 | 4.227 | 4.227 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -7801.073    -7801.073   -7976.2839   -7976.2839    338.95726    338.95726    124766.53    124766.53    179.98031    179.98031 
   15000   -7810.8403   -7810.8403   -7984.5057   -7984.5057    335.96748    335.96748    124553.27    124553.27    436.83926    436.83926 
Loop time of 100.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.856 ns/day, 28.050 hours/ns, 9.903 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.54     | 100.54     | 100.54     |   0.0 | 99.57
Neigh   | 0.055533   | 0.055533   | 0.055533   |   0.0 |  0.05
Comm    | 0.043878   | 0.043878   | 0.043878   |   0.0 |  0.04
Output  | 0.00011721 | 0.00011721 | 0.00011721 |   0.0 |  0.00
Modify  | 0.29675    | 0.29675    | 0.29675    |   0.0 |  0.29
Other   |            | 0.04298    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4864.00 ave        4864 max        4864 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218334.0 ave      218334 max      218334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218334
Ave neighs/atom = 54.583500
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 = 333.793539555185, Press = -2.6382817026052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7810.8403   -7810.8403   -7984.5057   -7984.5057    335.96748    335.96748    124553.27    124553.27    436.83926    436.83926 
   16000    -7810.782    -7810.782   -7982.6914   -7982.6914    332.57037    332.57037    124662.46    124662.46    84.070682    84.070682 
Loop time of 100.695 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.858 ns/day, 27.971 hours/ns, 9.931 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    | 100.24     | 100.24     | 100.24     |   0.0 | 99.55
Neigh   | 0.074148   | 0.074148   | 0.074148   |   0.0 |  0.07
Comm    | 0.044092   | 0.044092   | 0.044092   |   0.0 |  0.04
Output  | 0.00010075 | 0.00010075 | 0.00010075 |   0.0 |  0.00
Modify  | 0.29289    | 0.29289    | 0.29289    |   0.0 |  0.29
Other   |            | 0.04075    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4750.00 ave        4750 max        4750 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218216.0 ave      218216 max      218216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218216
Ave neighs/atom = 54.554000
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 = 333.686166101918, Press = -3.55890179231641
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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    -7810.782    -7810.782   -7982.6914   -7982.6914    332.57037    332.57037    124662.46    124662.46    84.070682    84.070682 
   17000   -7810.6275   -7810.6275   -7984.9751   -7984.9751    337.28733    337.28733    124698.96    124698.96   -156.69099   -156.69099 
Loop time of 100.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.856 ns/day, 28.032 hours/ns, 9.909 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.45     | 100.45     | 100.45     |   0.0 | 99.54
Neigh   | 0.074332   | 0.074332   | 0.074332   |   0.0 |  0.07
Comm    | 0.044656   | 0.044656   | 0.044656   |   0.0 |  0.04
Output  | 9.7849e-05 | 9.7849e-05 | 9.7849e-05 |   0.0 |  0.00
Modify  | 0.29929    | 0.29929    | 0.29929    |   0.0 |  0.30
Other   |            | 0.04513    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4785.00 ave        4785 max        4785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218116.0 ave      218116 max      218116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218116
Ave neighs/atom = 54.529000
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 = 333.767311857267, Press = -1.35802021015921
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   17000   -7810.6275   -7810.6275   -7984.9751   -7984.9751    337.28733    337.28733    124698.96    124698.96   -156.69099   -156.69099 
   18000   -7810.7138   -7810.7138    -7980.663    -7980.663    328.77818    328.77818    124784.05    124784.05   -268.06311   -268.06311 
Loop time of 101.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.854 ns/day, 28.091 hours/ns, 9.888 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    | 100.66     | 100.66     | 100.66     |   0.0 | 99.54
Neigh   | 0.074333   | 0.074333   | 0.074333   |   0.0 |  0.07
Comm    | 0.045751   | 0.045751   | 0.045751   |   0.0 |  0.05
Output  | 8.7488e-05 | 8.7488e-05 | 8.7488e-05 |   0.0 |  0.00
Modify  | 0.30066    | 0.30066    | 0.30066    |   0.0 |  0.30
Other   |            | 0.04618    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4835.00 ave        4835 max        4835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218398.0 ave      218398 max      218398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218398
Ave neighs/atom = 54.599500
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 = 333.709527278633, Press = -0.919210638863793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   18000   -7810.7138   -7810.7138    -7980.663    -7980.663    328.77818    328.77818    124784.05    124784.05   -268.06311   -268.06311 
   19000   -7806.7523   -7806.7523   -7980.4729   -7980.4729    336.07438    336.07438    124712.44    124712.44    46.509919    46.509919 
Loop time of 101.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.855 ns/day, 28.076 hours/ns, 9.894 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    | 100.61     | 100.61     | 100.61     |   0.0 | 99.54
Neigh   | 0.07386    | 0.07386    | 0.07386    |   0.0 |  0.07
Comm    | 0.044988   | 0.044988   | 0.044988   |   0.0 |  0.04
Output  | 0.00020903 | 0.00020903 | 0.00020903 |   0.0 |  0.00
Modify  | 0.29978    | 0.29978    | 0.29978    |   0.0 |  0.30
Other   |            | 0.04557    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4811.00 ave        4811 max        4811 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218140.0 ave      218140 max      218140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218140
Ave neighs/atom = 54.535000
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 = 333.589738135539, Press = -1.6411043211901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7806.7523   -7806.7523   -7980.4729   -7980.4729    336.07438    336.07438    124712.44    124712.44    46.509919    46.509919 
   20000   -7802.8477   -7802.8477   -7978.5702   -7978.5702      339.947      339.947    124866.89    124866.89   -264.59446   -264.59446 
Loop time of 101.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.160 hours/ns, 9.864 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    | 100.9      | 100.9      | 100.9      |   0.0 | 99.53
Neigh   | 0.074162   | 0.074162   | 0.074162   |   0.0 |  0.07
Comm    | 0.046029   | 0.046029   | 0.046029   |   0.0 |  0.05
Output  | 0.00010254 | 0.00010254 | 0.00010254 |   0.0 |  0.00
Modify  | 0.30595    | 0.30595    | 0.30595    |   0.0 |  0.30
Other   |            | 0.04863    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4841.00 ave        4841 max        4841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218040.0 ave      218040 max      218040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218040
Ave neighs/atom = 54.510000
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 = 333.540318168523, Press = -1.30257289459514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7802.8477   -7802.8477   -7978.5702   -7978.5702      339.947      339.947    124866.89    124866.89   -264.59446   -264.59446 
   21000   -7807.1641   -7807.1641     -7980.47     -7980.47     335.2721     335.2721    124619.37    124619.37    387.46818    387.46818 
Loop time of 100.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.857 ns/day, 28.002 hours/ns, 9.920 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    | 100.34     | 100.34     | 100.34     |   0.0 | 99.54
Neigh   | 0.074083   | 0.074083   | 0.074083   |   0.0 |  0.07
Comm    | 0.044706   | 0.044706   | 0.044706   |   0.0 |  0.04
Output  | 0.00010251 | 0.00010251 | 0.00010251 |   0.0 |  0.00
Modify  | 0.30015    | 0.30015    | 0.30015    |   0.0 |  0.30
Other   |            | 0.04492    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4766.00 ave        4766 max        4766 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218038.0 ave      218038 max      218038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218038
Ave neighs/atom = 54.509500
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 = 333.593135447146, Press = -1.67467977872593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7807.1641   -7807.1641     -7980.47     -7980.47     335.2721     335.2721    124619.37    124619.37    387.46818    387.46818 
   22000   -7808.7558   -7808.7558   -7980.7137   -7980.7137    332.66418    332.66418    124701.21    124701.21    88.235793    88.235793 
Loop time of 100.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.857 ns/day, 28.014 hours/ns, 9.916 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    | 100.38     | 100.38     | 100.38     |   0.0 | 99.54
Neigh   | 0.074144   | 0.074144   | 0.074144   |   0.0 |  0.07
Comm    | 0.045423   | 0.045423   | 0.045423   |   0.0 |  0.05
Output  | 8.6007e-05 | 8.6007e-05 | 8.6007e-05 |   0.0 |  0.00
Modify  | 0.30241    | 0.30241    | 0.30241    |   0.0 |  0.30
Other   |            | 0.04676    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4836.00 ave        4836 max        4836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218040.0 ave      218040 max      218040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218040
Ave neighs/atom = 54.510000
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 = 333.60833401759, Press = -1.07288988902949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7808.7558   -7808.7558   -7980.7137   -7980.7137    332.66418    332.66418    124701.21    124701.21    88.235793    88.235793 
   23000   -7804.7253   -7804.7253   -7978.8453   -7978.8453    336.84696    336.84696    124886.16    124886.16   -435.30154   -435.30154 
Loop time of 101.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.854 ns/day, 28.110 hours/ns, 9.882 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    | 100.74     | 100.74     | 100.74     |   0.0 | 99.55
Neigh   | 0.074312   | 0.074312   | 0.074312   |   0.0 |  0.07
Comm    | 0.045299   | 0.045299   | 0.045299   |   0.0 |  0.04
Output  | 9.5009e-05 | 9.5009e-05 | 9.5009e-05 |   0.0 |  0.00
Modify  | 0.29707    | 0.29707    | 0.29707    |   0.0 |  0.29
Other   |            | 0.04198    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4854.00 ave        4854 max        4854 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218304.0 ave      218304 max      218304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218304
Ave neighs/atom = 54.576000
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 = 333.595063113297, Press = -1.14493224513303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -7804.7253   -7804.7253   -7978.8453   -7978.8453    336.84696    336.84696    124886.16    124886.16   -435.30154   -435.30154 
   24000   -7808.9679   -7808.9679   -7982.0703   -7982.0703     334.8782     334.8782    124856.12    124856.12   -522.08958   -522.08958 
Loop time of 100.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.934 hours/ns, 9.944 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    | 100.12     | 100.12     | 100.12     |   0.0 | 99.56
Neigh   | 0.074232   | 0.074232   | 0.074232   |   0.0 |  0.07
Comm    | 0.043259   | 0.043259   | 0.043259   |   0.0 |  0.04
Output  | 9.6789e-05 | 9.6789e-05 | 9.6789e-05 |   0.0 |  0.00
Modify  | 0.28959    | 0.28959    | 0.28959    |   0.0 |  0.29
Other   |            | 0.03784    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4787.00 ave        4787 max        4787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218110.0 ave      218110 max      218110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218110
Ave neighs/atom = 54.527500
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 = 333.638579909917, Press = -1.73161718397675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   24000   -7808.9679   -7808.9679   -7982.0703   -7982.0703     334.8782     334.8782    124856.12    124856.12   -522.08958   -522.08958 
   25000   -7807.3913   -7807.3913   -7982.4555   -7982.4555    338.67344    338.67344    124720.01    124720.01    11.778615    11.778615 
Loop time of 100.497 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.860 ns/day, 27.916 hours/ns, 9.951 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    | 100.08     | 100.08     | 100.08     |   0.0 | 99.58
Neigh   | 0.0554     | 0.0554     | 0.0554     |   0.0 |  0.06
Comm    | 0.042882   | 0.042882   | 0.042882   |   0.0 |  0.04
Output  | 0.00010896 | 0.00010896 | 0.00010896 |   0.0 |  0.00
Modify  | 0.28455    | 0.28455    | 0.28455    |   0.0 |  0.28
Other   |            | 0.03551    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4863.00 ave        4863 max        4863 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218164.0 ave      218164 max      218164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218164
Ave neighs/atom = 54.541000
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 = 333.570403269183, Press = -1.19944522571209
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   25000   -7807.3913   -7807.3913   -7982.4555   -7982.4555    338.67344    338.67344    124720.01    124720.01    11.778615    11.778615 
   26000   -7807.0242   -7807.0242   -7978.5586   -7978.5586    331.84511    331.84511    124821.31    124821.31   -157.00313   -157.00313 
Loop time of 100.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.861 ns/day, 27.888 hours/ns, 9.961 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    | 99.96      | 99.96      | 99.96      |   0.0 | 99.57
Neigh   | 0.07383    | 0.07383    | 0.07383    |   0.0 |  0.07
Comm    | 0.042966   | 0.042966   | 0.042966   |   0.0 |  0.04
Output  | 7.3545e-05 | 7.3545e-05 | 7.3545e-05 |   0.0 |  0.00
Modify  | 0.28314    | 0.28314    | 0.28314    |   0.0 |  0.28
Other   |            | 0.03467    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4787.00 ave        4787 max        4787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      217932.0 ave      217932 max      217932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217932
Ave neighs/atom = 54.483000
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 = 333.520473540641, Press = -1.4072827542783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   26000   -7807.0242   -7807.0242   -7978.5586   -7978.5586    331.84511    331.84511    124821.31    124821.31   -157.00313   -157.00313 
   27000   -7812.5723   -7812.5723   -7981.5214   -7981.5214    326.84356    326.84356    124850.09    124850.09   -563.05417   -563.05417 
Loop time of 100.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.860 ns/day, 27.891 hours/ns, 9.959 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.976     | 99.976     | 99.976     |   0.0 | 99.57
Neigh   | 0.073933   | 0.073933   | 0.073933   |   0.0 |  0.07
Comm    | 0.042879   | 0.042879   | 0.042879   |   0.0 |  0.04
Output  | 0.00010123 | 0.00010123 | 0.00010123 |   0.0 |  0.00
Modify  | 0.2822     | 0.2822     | 0.2822     |   0.0 |  0.28
Other   |            | 0.03417    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4813.00 ave        4813 max        4813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218172.0 ave      218172 max      218172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218172
Ave neighs/atom = 54.543000
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 = 333.442296182461, Press = -0.804782308017721
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   27000   -7812.5723   -7812.5723   -7981.5214   -7981.5214    326.84356    326.84356    124850.09    124850.09   -563.05417   -563.05417 
   28000   -7810.7094   -7810.7094   -7982.5429   -7982.5429    332.42361    332.42361    124831.19    124831.19   -514.44267   -514.44267 
Loop time of 100.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.861 ns/day, 27.874 hours/ns, 9.966 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.914     | 99.914     | 99.914     |   0.0 | 99.57
Neigh   | 0.073597   | 0.073597   | 0.073597   |   0.0 |  0.07
Comm    | 0.042968   | 0.042968   | 0.042968   |   0.0 |  0.04
Output  | 9.4352e-05 | 9.4352e-05 | 9.4352e-05 |   0.0 |  0.00
Modify  | 0.2815     | 0.2815     | 0.2815     |   0.0 |  0.28
Other   |            | 0.03366    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4805.00 ave        4805 max        4805 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218210.0 ave      218210 max      218210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218210
Ave neighs/atom = 54.552500
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 = 333.449302929032, Press = -1.17441382070907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   28000   -7810.7094   -7810.7094   -7982.5429   -7982.5429    332.42361    332.42361    124831.19    124831.19   -514.44267   -514.44267 
   29000   -7806.2479   -7806.2479   -7980.9086   -7980.9086    337.89304    337.89304    124849.03    124849.03   -372.21149   -372.21149 
Loop time of 100.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.861 ns/day, 27.875 hours/ns, 9.965 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    | 99.919     | 99.919     | 99.919     |   0.0 | 99.57
Neigh   | 0.074013   | 0.074013   | 0.074013   |   0.0 |  0.07
Comm    | 0.042562   | 0.042562   | 0.042562   |   0.0 |  0.04
Output  | 9.5295e-05 | 9.5295e-05 | 9.5295e-05 |   0.0 |  0.00
Modify  | 0.28117    | 0.28117    | 0.28117    |   0.0 |  0.28
Other   |            | 0.03349    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4835.00 ave        4835 max        4835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218246.0 ave      218246 max      218246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218246
Ave neighs/atom = 54.561500
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 = 333.397685788457, Press = -0.267975733792943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   29000   -7806.2479   -7806.2479   -7980.9086   -7980.9086    337.89304    337.89304    124849.03    124849.03   -372.21149   -372.21149 
   30000   -7806.2318   -7806.2318   -7978.5571   -7978.5571    333.37509    333.37509       124837       124837   -254.85463   -254.85463 
Loop time of 100.526 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.924 hours/ns, 9.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.09     | 100.09     | 100.09     |   0.0 | 99.57
Neigh   | 0.073861   | 0.073861   | 0.073861   |   0.0 |  0.07
Comm    | 0.042987   | 0.042987   | 0.042987   |   0.0 |  0.04
Output  | 9.4766e-05 | 9.4766e-05 | 9.4766e-05 |   0.0 |  0.00
Modify  | 0.28142    | 0.28142    | 0.28142    |   0.0 |  0.28
Other   |            | 0.03369    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4885.00 ave        4885 max        4885 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218220.0 ave      218220 max      218220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218220
Ave neighs/atom = 54.555000
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 = 333.366483958057, Press = 0.208060563412609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   30000   -7806.2318   -7806.2318   -7978.5571   -7978.5571    333.37509    333.37509       124837       124837   -254.85463   -254.85463 
   31000    -7801.926    -7801.926   -7978.7955   -7978.7955    342.16601    342.16601    124767.03    124767.03    76.348007    76.348007 
Loop time of 100.639 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.955 hours/ns, 9.937 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.21     | 100.21     | 100.21     |   0.0 | 99.57
Neigh   | 0.074037   | 0.074037   | 0.074037   |   0.0 |  0.07
Comm    | 0.042727   | 0.042727   | 0.042727   |   0.0 |  0.04
Output  | 9.3843e-05 | 9.3843e-05 | 9.3843e-05 |   0.0 |  0.00
Modify  | 0.28165    | 0.28165    | 0.28165    |   0.0 |  0.28
Other   |            | 0.03359    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4761.00 ave        4761 max        4761 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      217776.0 ave      217776 max      217776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217776
Ave neighs/atom = 54.444000
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 = 333.394810566674, Press = 0.158419010495243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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 
   31000    -7801.926    -7801.926   -7978.7955   -7978.7955    342.16601    342.16601    124767.03    124767.03    76.348007    76.348007 
   32000   -7806.4258   -7806.4258   -7977.2727   -7977.2727    330.51483    330.51483    124800.93    124800.93   -24.591603   -24.591603 
Loop time of 100.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.950 hours/ns, 9.938 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    | 100.19     | 100.19     | 100.19     |   0.0 | 99.57
Neigh   | 0.074039   | 0.074039   | 0.074039   |   0.0 |  0.07
Comm    | 0.042902   | 0.042902   | 0.042902   |   0.0 |  0.04
Output  | 8.1426e-05 | 8.1426e-05 | 8.1426e-05 |   0.0 |  0.00
Modify  | 0.28169    | 0.28169    | 0.28169    |   0.0 |  0.28
Other   |            | 0.03373    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4812.00 ave        4812 max        4812 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      218012.0 ave      218012 max      218012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 218012
Ave neighs/atom = 54.503000
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"
jump SELF break

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0