# 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 2.866965785622597*${_u_distance}
variable latticeconst_converted equal 2.866965785622597*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.8669657856226
Lattice spacing in x,y,z = 2.8669658 2.8669658 2.8669658
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 (28.669658 28.669658 28.669658)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.669658 28.669658 28.669658)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BonnyTerentyevPasianot_2011_FeNiCr__MO_677715648236_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_677715648236_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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7943.6608   -7943.6608   -8009.0725   -8009.0725       253.15       253.15    23565.005    23565.005     2964.884     2964.884 
    1000   -8008.3976   -8008.3976   -8074.3696   -8074.3696    255.31862    255.31862    21548.814    21548.814    51.869829    51.869829 
Loop time of 32.0064 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.891 hours/ns, 31.244 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    | 31.313     | 31.313     | 31.313     |   0.0 | 97.83
Neigh   | 0.14286    | 0.14286    | 0.14286    |   0.0 |  0.45
Comm    | 0.12924    | 0.12924    | 0.12924    |   0.0 |  0.40
Output  | 0.00019678 | 0.00019678 | 0.00019678 |   0.0 |  0.00
Modify  | 0.35575    | 0.35575    | 0.35575    |   0.0 |  1.11
Other   |            | 0.06576    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 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:      334140.0 ave      334140 max      334140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334140
Ave neighs/atom = 167.07000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8008.3976   -8008.3976   -8074.3696   -8074.3696    255.31862    255.31862    21548.814    21548.814    51.869829    51.869829 
    2000    -8044.862    -8044.862   -8110.4536   -8110.4536    253.84623    253.84623    21558.784    21558.784    -94.51998    -94.51998 
Loop time of 31.3022 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.695 hours/ns, 31.947 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    | 30.717     | 30.717     | 30.717     |   0.0 | 98.13
Neigh   | 0.047538   | 0.047538   | 0.047538   |   0.0 |  0.15
Comm    | 0.12513    | 0.12513    | 0.12513    |   0.0 |  0.40
Output  | 0.00025098 | 0.00025098 | 0.00025098 |   0.0 |  0.00
Modify  | 0.34777    | 0.34777    | 0.34777    |   0.0 |  1.11
Other   |            | 0.06494    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 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:      331938.0 ave      331938 max      331938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331938
Ave neighs/atom = 165.96900
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -8044.862    -8044.862   -8110.4536   -8110.4536    253.84623    253.84623    21558.784    21558.784    -94.51998    -94.51998 
    3000   -8051.9294   -8051.9294    -8116.257    -8116.257     248.9542     248.9542    21489.658    21489.658    916.55999    916.55999 
Loop time of 31.962 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.878 hours/ns, 31.287 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    | 31.414     | 31.414     | 31.414     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.39
Output  | 0.00018828 | 0.00018828 | 0.00018828 |   0.0 |  0.00
Modify  | 0.35513    | 0.35513    | 0.35513    |   0.0 |  1.11
Other   |            | 0.06642    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      332332.0 ave      332332 max      332332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332332
Ave neighs/atom = 166.16600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8051.9294   -8051.9294    -8116.257    -8116.257     248.9542     248.9542    21489.658    21489.658    916.55999    916.55999 
    4000    -8048.129    -8048.129   -8115.2574   -8115.2574    259.79364    259.79364    21476.182    21476.182    3396.4457    3396.4457 
Loop time of 31.7438 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.818 hours/ns, 31.502 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    | 31.206     | 31.206     | 31.206     |   0.0 | 98.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12374    | 0.12374    | 0.12374    |   0.0 |  0.39
Output  | 0.00023049 | 0.00023049 | 0.00023049 |   0.0 |  0.00
Modify  | 0.34848    | 0.34848    | 0.34848    |   0.0 |  1.10
Other   |            | 0.06575    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      333290.0 ave      333290 max      333290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333290
Ave neighs/atom = 166.64500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8048.129    -8048.129   -8115.2574   -8115.2574    259.79364    259.79364    21476.182    21476.182    3396.4457    3396.4457 
    5000   -8047.0797   -8047.0797   -8112.4134   -8112.4134    252.84835    252.84835    21520.987    21520.987    2298.9027    2298.9027 
Loop time of 32.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.971 hours/ns, 30.965 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    | 31.701     | 31.701     | 31.701     |   0.0 | 98.16
Neigh   | 0.046679   | 0.046679   | 0.046679   |   0.0 |  0.14
Comm    | 0.12556    | 0.12556    | 0.12556    |   0.0 |  0.39
Output  | 0.00015307 | 0.00015307 | 0.00015307 |   0.0 |  0.00
Modify  | 0.35528    | 0.35528    | 0.35528    |   0.0 |  1.10
Other   |            | 0.06601    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 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:      332746.0 ave      332746 max      332746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332746
Ave neighs/atom = 166.37300
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.03434110495, Press = 101.321171821931
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8047.0797   -8047.0797   -8112.4134   -8112.4134    252.84835    252.84835    21520.987    21520.987    2298.9027    2298.9027 
    6000   -8048.2938   -8048.2938   -8112.9237   -8112.9237    250.12423    250.12423    21554.104    21554.104   -725.63412   -725.63412 
Loop time of 31.6356 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.788 hours/ns, 31.610 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    | 31.077     | 31.077     | 31.077     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12376    | 0.12376    | 0.12376    |   0.0 |  0.39
Output  | 0.00015651 | 0.00015651 | 0.00015651 |   0.0 |  0.00
Modify  | 0.36939    | 0.36939    | 0.36939    |   0.0 |  1.17
Other   |            | 0.06519    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      332696.0 ave      332696 max      332696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332696
Ave neighs/atom = 166.34800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.823345545536, Press = 6.70537006341631
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8048.2938   -8048.2938   -8112.9237   -8112.9237    250.12423    250.12423    21554.104    21554.104   -725.63412   -725.63412 
    7000   -8051.4743   -8051.4743   -8116.5143   -8116.5143    251.71134    251.71134    21522.662    21522.662    960.18782    960.18782 
Loop time of 32.9607 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.621 ns/day, 9.156 hours/ns, 30.339 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    | 32.381     | 32.381     | 32.381     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1276     | 0.1276     | 0.1276     |   0.0 |  0.39
Output  | 0.00015237 | 0.00015237 | 0.00015237 |   0.0 |  0.00
Modify  | 0.38535    | 0.38535    | 0.38535    |   0.0 |  1.17
Other   |            | 0.06642    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 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:      332282.0 ave      332282 max      332282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332282
Ave neighs/atom = 166.14100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.971093229838, Press = 47.012303023664
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8051.4743   -8051.4743   -8116.5143   -8116.5143    251.71134    251.71134    21522.662    21522.662    960.18782    960.18782 
    8000   -8051.2362   -8051.2362   -8115.0054   -8115.0054    246.79334    246.79334      21503.9      21503.9    1538.2072    1538.2072 
Loop time of 32.8224 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.632 ns/day, 9.117 hours/ns, 30.467 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    | 32.248     | 32.248     | 32.248     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12725    | 0.12725    | 0.12725    |   0.0 |  0.39
Output  | 0.00019621 | 0.00019621 | 0.00019621 |   0.0 |  0.00
Modify  | 0.3807     | 0.3807     | 0.3807     |   0.0 |  1.16
Other   |            | 0.06603    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 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:      333082.0 ave      333082 max      333082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333082
Ave neighs/atom = 166.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.675057574011, Press = -6.77087255097139
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8051.2362   -8051.2362   -8115.0054   -8115.0054    246.79334    246.79334      21503.9      21503.9    1538.2072    1538.2072 
    9000    -8050.459    -8050.459   -8115.6397   -8115.6397    252.25604    252.25604     21542.63     21542.63    -1218.363    -1218.363 
Loop time of 32.9482 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.152 hours/ns, 30.351 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    | 32.373     | 32.373     | 32.373     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12772    | 0.12772    | 0.12772    |   0.0 |  0.39
Output  | 0.00015378 | 0.00015378 | 0.00015378 |   0.0 |  0.00
Modify  | 0.38169    | 0.38169    | 0.38169    |   0.0 |  1.16
Other   |            | 0.06611    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 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:      333178.0 ave      333178 max      333178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333178
Ave neighs/atom = 166.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.347151372911, Press = 15.6242013911775
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8050.459    -8050.459   -8115.6397   -8115.6397    252.25604    252.25604     21542.63     21542.63    -1218.363    -1218.363 
   10000   -8052.7135   -8052.7135   -8116.3387   -8116.3387    246.23629    246.23629    21546.099    21546.099   -625.20712   -625.20712 
Loop time of 33.2182 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.601 ns/day, 9.227 hours/ns, 30.104 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    | 32.636     | 32.636     | 32.636     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12807    | 0.12807    | 0.12807    |   0.0 |  0.39
Output  | 0.0001969  | 0.0001969  | 0.0001969  |   0.0 |  0.00
Modify  | 0.38843    | 0.38843    | 0.38843    |   0.0 |  1.17
Other   |            | 0.06539    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      332886.0 ave      332886 max      332886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332886
Ave neighs/atom = 166.44300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.234336451554, Press = -12.4465950046422
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8052.7135   -8052.7135   -8116.3387   -8116.3387    246.23629    246.23629    21546.099    21546.099   -625.20712   -625.20712 
   11000   -8049.8123   -8049.8123   -8113.5827   -8113.5827    246.79776    246.79776    21554.893    21554.893    -1889.922    -1889.922 
Loop time of 32.2813 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.967 hours/ns, 30.978 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    | 31.713     | 31.713     | 31.713     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12659    | 0.12659    | 0.12659    |   0.0 |  0.39
Output  | 0.00015307 | 0.00015307 | 0.00015307 |   0.0 |  0.00
Modify  | 0.37549    | 0.37549    | 0.37549    |   0.0 |  1.16
Other   |            | 0.06622    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 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:      332578.0 ave      332578 max      332578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332578
Ave neighs/atom = 166.28900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.018415445745, Press = 1.38095802585372
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8049.8123   -8049.8123   -8113.5827   -8113.5827    246.79776    246.79776    21554.893    21554.893    -1889.922    -1889.922 
   12000    -8052.043    -8052.043   -8116.0662   -8116.0662    247.77622    247.77622    21542.177    21542.177   -1302.8383   -1302.8383 
Loop time of 34.0544 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.537 ns/day, 9.460 hours/ns, 29.365 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    | 33.465     | 33.465     | 33.465     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12942    | 0.12942    | 0.12942    |   0.0 |  0.38
Output  | 0.00020105 | 0.00020105 | 0.00020105 |   0.0 |  0.00
Modify  | 0.39371    | 0.39371    | 0.39371    |   0.0 |  1.16
Other   |            | 0.06654    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      332464.0 ave      332464 max      332464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332464
Ave neighs/atom = 166.23200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.08637338468, Press = -3.35904506564064
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -8052.043    -8052.043   -8116.0662   -8116.0662    247.77622    247.77622    21542.177    21542.177   -1302.8383   -1302.8383 
   13000   -8049.7164   -8049.7164   -8115.7717   -8115.7717    255.64086    255.64086     21526.03     21526.03   -424.81214   -424.81214 
Loop time of 32.7064 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.085 hours/ns, 30.575 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    | 32.136     | 32.136     | 32.136     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12637    | 0.12637    | 0.12637    |   0.0 |  0.39
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.37828    | 0.37828    | 0.37828    |   0.0 |  1.16
Other   |            | 0.06518    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 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:      332772.0 ave      332772 max      332772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332772
Ave neighs/atom = 166.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.183255751805, Press = 0.637757249975173
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8049.7164   -8049.7164   -8115.7717   -8115.7717    255.64086    255.64086     21526.03     21526.03   -424.81214   -424.81214 
   14000    -8049.072    -8049.072   -8114.7643   -8114.7643    254.23623    254.23623    21544.521    21544.521   -513.22713   -513.22713 
Loop time of 32.6667 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.645 ns/day, 9.074 hours/ns, 30.612 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    | 32.095     | 32.095     | 32.095     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12707    | 0.12707    | 0.12707    |   0.0 |  0.39
Output  | 0.00015716 | 0.00015716 | 0.00015716 |   0.0 |  0.00
Modify  | 0.37833    | 0.37833    | 0.37833    |   0.0 |  1.16
Other   |            | 0.0658     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5458.00 ave        5458 max        5458 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:      332802.0 ave      332802 max      332802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332802
Ave neighs/atom = 166.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.015617618344, Press = -0.0354252001811864
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -8049.072    -8049.072   -8114.7643   -8114.7643    254.23623    254.23623    21544.521    21544.521   -513.22713   -513.22713 
   15000   -8054.7095   -8054.7095   -8119.1502   -8119.1502    249.39207    249.39207    21489.682    21489.682    403.95296    403.95296 
Loop time of 32.1438 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.929 hours/ns, 31.110 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    | 31.574     | 31.574     | 31.574     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12578    | 0.12578    | 0.12578    |   0.0 |  0.39
Output  | 0.00018759 | 0.00018759 | 0.00018759 |   0.0 |  0.00
Modify  | 0.37702    | 0.37702    | 0.37702    |   0.0 |  1.17
Other   |            | 0.06661    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      332456.0 ave      332456 max      332456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332456
Ave neighs/atom = 166.22800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 251.995250141106, Press = -3.85151660563186
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8054.7095   -8054.7095   -8119.1502   -8119.1502    249.39207    249.39207    21489.682    21489.682    403.95296    403.95296 
   16000   -8048.6933   -8048.6933   -8114.2771   -8114.2771    253.81628    253.81628    21497.415    21497.415    2668.3405    2668.3405 
Loop time of 31.8402 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.844 hours/ns, 31.407 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    | 31.282     | 31.282     | 31.282     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.39
Output  | 0.00019363 | 0.00019363 | 0.00019363 |   0.0 |  0.00
Modify  | 0.36842    | 0.36842    | 0.36842    |   0.0 |  1.16
Other   |            | 0.06622    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      333406.0 ave      333406 max      333406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333406
Ave neighs/atom = 166.70300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.032468432528, Press = -8.947194975192
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8048.6933   -8048.6933   -8114.2771   -8114.2771    253.81628    253.81628    21497.415    21497.415    2668.3405    2668.3405 
   17000   -8049.6357   -8049.6357   -8115.4922   -8115.4922    254.87138    254.87138    21519.665    21519.665    915.16831    915.16831 
Loop time of 32.0231 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.895 hours/ns, 31.227 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    | 31.458     | 31.458     | 31.458     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12513    | 0.12513    | 0.12513    |   0.0 |  0.39
Output  | 0.00019605 | 0.00019605 | 0.00019605 |   0.0 |  0.00
Modify  | 0.37396    | 0.37396    | 0.37396    |   0.0 |  1.17
Other   |            | 0.06578    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 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:      333548.0 ave      333548 max      333548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333548
Ave neighs/atom = 166.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.159647733185, Press = -6.31545832262743
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8049.6357   -8049.6357   -8115.4922   -8115.4922    254.87138    254.87138    21519.665    21519.665    915.16831    915.16831 
   18000   -8050.5389   -8050.5389   -8117.1457   -8117.1457    257.77532    257.77532     21499.68     21499.68    890.38217    890.38217 
Loop time of 32.7633 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.101 hours/ns, 30.522 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    | 32.192     | 32.192     | 32.192     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12676    | 0.12676    | 0.12676    |   0.0 |  0.39
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.37872    | 0.37872    | 0.37872    |   0.0 |  1.16
Other   |            | 0.06523    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      332824.0 ave      332824 max      332824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332824
Ave neighs/atom = 166.41200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.447919538867, Press = -2.85306014621206
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8050.5389   -8050.5389   -8117.1457   -8117.1457    257.77532    257.77532     21499.68     21499.68    890.38217    890.38217 
   19000   -8048.1918   -8048.1918   -8115.8904   -8115.8904     262.0007     262.0007    21514.465    21514.465     804.8082     804.8082 
Loop time of 32.7046 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.085 hours/ns, 30.577 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    | 32.137     | 32.137     | 32.137     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.38
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.37669    | 0.37669    | 0.37669    |   0.0 |  1.15
Other   |            | 0.06563    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 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:      333280.0 ave      333280 max      333280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333280
Ave neighs/atom = 166.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.533410601601, Press = 0.0957477198537911
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8048.1918   -8048.1918   -8115.8904   -8115.8904     262.0007     262.0007    21514.465    21514.465     804.8082     804.8082 
   20000   -8051.2681   -8051.2681   -8115.4066   -8115.4066    248.22272    248.22272    21526.636    21526.636     1409.687     1409.687 
Loop time of 31.9075 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.708 ns/day, 8.863 hours/ns, 31.341 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    | 31.347     | 31.347     | 31.347     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.124      | 0.124      | 0.124      |   0.0 |  0.39
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.37079    | 0.37079    | 0.37079    |   0.0 |  1.16
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 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:      333412.0 ave      333412 max      333412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333412
Ave neighs/atom = 166.70600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.70439706565, Press = -3.69675664924128
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8051.2681   -8051.2681   -8115.4066   -8115.4066    248.22272    248.22272    21526.636    21526.636     1409.687     1409.687 
   21000   -8049.8594   -8049.8594   -8114.3501   -8114.3501    249.58553    249.58553    21515.317    21515.317    2142.8719    2142.8719 
Loop time of 32.2665 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.963 hours/ns, 30.992 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    | 31.702     | 31.702     | 31.702     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12607    | 0.12607    | 0.12607    |   0.0 |  0.39
Output  | 0.00018905 | 0.00018905 | 0.00018905 |   0.0 |  0.00
Modify  | 0.37345    | 0.37345    | 0.37345    |   0.0 |  1.16
Other   |            | 0.06519    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 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:      332980.0 ave      332980 max      332980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332980
Ave neighs/atom = 166.49000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.732901987214, Press = -2.02846475011786
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8049.8594   -8049.8594   -8114.3501   -8114.3501    249.58553    249.58553    21515.317    21515.317    2142.8719    2142.8719 
   22000   -8050.0501   -8050.0501   -8115.4668   -8115.4668    253.16952    253.16952     21494.06     21494.06     2907.181     2907.181 
Loop time of 32.3102 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.975 hours/ns, 30.950 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    | 31.741     | 31.741     | 31.741     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12538    | 0.12538    | 0.12538    |   0.0 |  0.39
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.3784     | 0.3784     | 0.3784     |   0.0 |  1.17
Other   |            | 0.06563    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 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:      332842.0 ave      332842 max      332842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332842
Ave neighs/atom = 166.42100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.731071404242, Press = 3.07317033205903
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8050.0501   -8050.0501   -8115.4668   -8115.4668    253.16952    253.16952     21494.06     21494.06     2907.181     2907.181 
   23000   -8052.0228   -8052.0228   -8116.2753   -8116.2753    248.66383    248.66383    21505.391    21505.391    1546.4725    1546.4725 
Loop time of 33.0478 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.614 ns/day, 9.180 hours/ns, 30.259 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    | 32.475     | 32.475     | 32.475     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12631    | 0.12631    | 0.12631    |   0.0 |  0.38
Output  | 0.00015328 | 0.00015328 | 0.00015328 |   0.0 |  0.00
Modify  | 0.3808     | 0.3808     | 0.3808     |   0.0 |  1.15
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      333328.0 ave      333328 max      333328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333328
Ave neighs/atom = 166.66400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.661442854202, Press = -0.432756592502366
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8052.0228   -8052.0228   -8116.2753   -8116.2753    248.66383    248.66383    21505.391    21505.391    1546.4725    1546.4725 
   24000    -8048.912    -8048.912   -8115.3113   -8115.3113    256.97218    256.97218    21562.659    21562.659   -1978.5505   -1978.5505 
Loop time of 33.0795 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.189 hours/ns, 30.230 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    | 32.504     | 32.504     | 32.504     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12797    | 0.12797    | 0.12797    |   0.0 |  0.39
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.38107    | 0.38107    | 0.38107    |   0.0 |  1.15
Other   |            | 0.06616    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 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:      333320.0 ave      333320 max      333320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333320
Ave neighs/atom = 166.66000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.648174535848, Press = 1.33371699953717
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -8048.912    -8048.912   -8115.3113   -8115.3113    256.97218    256.97218    21562.659    21562.659   -1978.5505   -1978.5505 
   25000   -8050.5498   -8050.5498   -8114.8396   -8114.8396    248.80784    248.80784    21530.946    21530.946    349.73701    349.73701 
Loop time of 32.4901 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.659 ns/day, 9.025 hours/ns, 30.779 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    | 31.923     | 31.923     | 31.923     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12545    | 0.12545    | 0.12545    |   0.0 |  0.39
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.37548    | 0.37548    | 0.37548    |   0.0 |  1.16
Other   |            | 0.06567    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      332456.0 ave      332456 max      332456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332456
Ave neighs/atom = 166.22800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.668761430773, Press = 1.86172757522895
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8050.5498   -8050.5498   -8114.8396   -8114.8396    248.80784    248.80784    21530.946    21530.946    349.73701    349.73701 
   26000   -8053.2884   -8053.2884   -8117.9403   -8117.9403    250.20958    250.20958    21501.311    21501.311    666.14485    666.14485 
Loop time of 34.0235 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.539 ns/day, 9.451 hours/ns, 29.391 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    | 33.437     | 33.437     | 33.437     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13018    | 0.13018    | 0.13018    |   0.0 |  0.38
Output  | 0.00019541 | 0.00019541 | 0.00019541 |   0.0 |  0.00
Modify  | 0.38998    | 0.38998    | 0.38998    |   0.0 |  1.15
Other   |            | 0.06587    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 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:      332772.0 ave      332772 max      332772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332772
Ave neighs/atom = 166.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.666311190767, Press = 3.10610915607506
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8053.2884   -8053.2884   -8117.9403   -8117.9403    250.20958    250.20958    21501.311    21501.311    666.14485    666.14485 
   27000   -8049.4705   -8049.4705   -8115.2562   -8115.2562    254.59722    254.59722    21523.062    21523.062    787.48226    787.48226 
Loop time of 32.4249 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.007 hours/ns, 30.840 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    | 31.857     | 31.857     | 31.857     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12642    | 0.12642    | 0.12642    |   0.0 |  0.39
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.37553    | 0.37553    | 0.37553    |   0.0 |  1.16
Other   |            | 0.06623    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 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:      332780.0 ave      332780 max      332780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332780
Ave neighs/atom = 166.39000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.63224283618, Press = -1.86578880271653
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8049.4705   -8049.4705   -8115.2562   -8115.2562    254.59722    254.59722    21523.062    21523.062    787.48226    787.48226 
   28000   -8052.9082   -8052.9082   -8118.1866   -8118.1866    252.63437    252.63437     21524.73     21524.73   -241.77348   -241.77348 
Loop time of 33.3846 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.588 ns/day, 9.273 hours/ns, 29.954 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    | 32.803     | 32.803     | 32.803     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12802    | 0.12802    | 0.12802    |   0.0 |  0.38
Output  | 0.00015269 | 0.00015269 | 0.00015269 |   0.0 |  0.00
Modify  | 0.38762    | 0.38762    | 0.38762    |   0.0 |  1.16
Other   |            | 0.0662     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 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:      332962.0 ave      332962 max      332962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332962
Ave neighs/atom = 166.48100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.675593084841, Press = 2.51897536166968
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8052.9082   -8052.9082   -8118.1866   -8118.1866    252.63437    252.63437     21524.73     21524.73   -241.77348   -241.77348 
   29000   -8048.0875   -8048.0875   -8113.9278   -8113.9278    254.80882    254.80882    21537.881    21537.881   -52.945398   -52.945398 
Loop time of 32.5586 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.714 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    | 31.987     | 31.987     | 31.987     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12614    | 0.12614    | 0.12614    |   0.0 |  0.39
Output  | 0.0001566  | 0.0001566  | 0.0001566  |   0.0 |  0.00
Modify  | 0.37896    | 0.37896    | 0.37896    |   0.0 |  1.16
Other   |            | 0.06642    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 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:      332890.0 ave      332890 max      332890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332890
Ave neighs/atom = 166.44500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.671141762355, Press = 0.381851104017153
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8048.0875   -8048.0875   -8113.9278   -8113.9278    254.80882    254.80882    21537.881    21537.881   -52.945398   -52.945398 
   30000   -8050.6825   -8050.6825    -8116.261    -8116.261    253.79545    253.79545    21517.298    21517.298    468.87599    468.87599 
Loop time of 32.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.685 ns/day, 8.940 hours/ns, 31.072 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.616     | 31.616     | 31.616     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1262     | 0.1262     | 0.1262     |   0.0 |  0.39
Output  | 0.00015965 | 0.00015965 | 0.00015965 |   0.0 |  0.00
Modify  | 0.37454    | 0.37454    | 0.37454    |   0.0 |  1.16
Other   |            | 0.06602    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 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:      332556.0 ave      332556 max      332556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332556
Ave neighs/atom = 166.27800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.760572885669, Press = -0.227248023006162
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8050.6825   -8050.6825    -8116.261    -8116.261    253.79545    253.79545    21517.298    21517.298    468.87599    468.87599 
   31000   -8047.9025   -8047.9025   -8114.8663   -8114.8663    259.15679    259.15679     21562.88     21562.88   -2470.4165   -2470.4165 
Loop time of 33.2363 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.600 ns/day, 9.232 hours/ns, 30.088 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    | 32.659     | 32.659     | 32.659     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.38
Output  | 0.00019683 | 0.00019683 | 0.00019683 |   0.0 |  0.00
Modify  | 0.3833     | 0.3833     | 0.3833     |   0.0 |  1.15
Other   |            | 0.06633    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 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:      332866.0 ave      332866 max      332866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332866
Ave neighs/atom = 166.43300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.822553419829, Press = -1.82477583622493
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8047.9025   -8047.9025   -8114.8663   -8114.8663    259.15679    259.15679     21562.88     21562.88   -2470.4165   -2470.4165 
   32000   -8051.3102   -8051.3102   -8114.6602   -8114.6602    245.17083    245.17083    21538.348    21538.348    102.77353    102.77353 
Loop time of 33.0917 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.611 ns/day, 9.192 hours/ns, 30.219 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    | 32.512     | 32.512     | 32.512     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12813    | 0.12813    | 0.12813    |   0.0 |  0.39
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.38593    | 0.38593    | 0.38593    |   0.0 |  1.17
Other   |            | 0.06598    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      332472.0 ave      332472 max      332472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332472
Ave neighs/atom = 166.23600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.909199679716, Press = -0.428429652434273
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8051.3102   -8051.3102   -8114.6602   -8114.6602    245.17083    245.17083    21538.348    21538.348    102.77353    102.77353 
   33000   -8049.5288   -8049.5288   -8116.4237   -8116.4237    258.89025    258.89025    21503.045    21503.045     2126.903     2126.903 
Loop time of 33.0339 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.615 ns/day, 9.176 hours/ns, 30.272 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    | 32.46      | 32.46      | 32.46      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12807    | 0.12807    | 0.12807    |   0.0 |  0.39
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.37974    | 0.37974    | 0.37974    |   0.0 |  1.15
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 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:      332658.0 ave      332658 max      332658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332658
Ave neighs/atom = 166.32900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.954890729441, Press = 2.22073026602735
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8049.5288   -8049.5288   -8116.4237   -8116.4237    258.89025    258.89025    21503.045    21503.045     2126.903     2126.903 
   34000   -8048.0753   -8048.0753   -8114.4465   -8114.4465    256.86359    256.86359    21528.311    21528.311    296.97796    296.97796 
Loop time of 33.5512 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.575 ns/day, 9.320 hours/ns, 29.805 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    | 32.964     | 32.964     | 32.964     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12945    | 0.12945    | 0.12945    |   0.0 |  0.39
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.39121    | 0.39121    | 0.39121    |   0.0 |  1.17
Other   |            | 0.06624    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 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:      333246.0 ave      333246 max      333246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333246
Ave neighs/atom = 166.62300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.973788451851, Press = 0.650677712512567
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8048.0753   -8048.0753   -8114.4465   -8114.4465    256.86359    256.86359    21528.311    21528.311    296.97796    296.97796 
   35000   -8050.1033   -8050.1033   -8114.1183   -8114.1183    247.74451    247.74451    21556.257    21556.257   -1503.1621   -1503.1621 
Loop time of 33.5536 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.575 ns/day, 9.320 hours/ns, 29.803 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    | 32.977     | 32.977     | 32.977     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.128      | 0.128      | 0.128      |   0.0 |  0.38
Output  | 0.00018963 | 0.00018963 | 0.00018963 |   0.0 |  0.00
Modify  | 0.38218    | 0.38218    | 0.38218    |   0.0 |  1.14
Other   |            | 0.06614    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 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:      332646.0 ave      332646 max      332646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332646
Ave neighs/atom = 166.32300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.935988218603, Press = 0.0870172421929449
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8050.1033   -8050.1033   -8114.1183   -8114.1183    247.74451    247.74451    21556.257    21556.257   -1503.1621   -1503.1621 
   36000   -8053.8994   -8053.8994   -8116.2121   -8116.2121    241.15686    241.15686     21550.57     21550.57    -2664.283    -2664.283 
Loop time of 32.7879 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.635 ns/day, 9.108 hours/ns, 30.499 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    | 32.218     | 32.218     | 32.218     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.38
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.37807    | 0.37807    | 0.37807    |   0.0 |  1.15
Other   |            | 0.06555    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      332478.0 ave      332478 max      332478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332478
Ave neighs/atom = 166.23900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.914990177072, Press = -1.9040200398114
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8053.8994   -8053.8994   -8116.2121   -8116.2121    241.15686    241.15686     21550.57     21550.57    -2664.283    -2664.283 
   37000   -8050.4165   -8050.4165   -8115.6997   -8115.6997    252.65288    252.65288    21516.112    21516.112    882.76037    882.76037 
Loop time of 33.9312 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.546 ns/day, 9.425 hours/ns, 29.471 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    | 33.343     | 33.343     | 33.343     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13001    | 0.13001    | 0.13001    |   0.0 |  0.38
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.39129    | 0.39129    | 0.39129    |   0.0 |  1.15
Other   |            | 0.06699    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      332454.0 ave      332454 max      332454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332454
Ave neighs/atom = 166.22700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.852247333578, Press = -0.785430107756686
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8050.4165   -8050.4165   -8115.6997   -8115.6997    252.65288    252.65288    21516.112    21516.112    882.76037    882.76037 
   38000   -8048.6624   -8048.6624   -8114.7423   -8114.7423    255.73598    255.73598    21513.574    21513.574    838.95166    838.95166 
Loop time of 33.8522 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.552 ns/day, 9.403 hours/ns, 29.540 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    | 33.268     | 33.268     | 33.268     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12908    | 0.12908    | 0.12908    |   0.0 |  0.38
Output  | 0.00015454 | 0.00015454 | 0.00015454 |   0.0 |  0.00
Modify  | 0.38883    | 0.38883    | 0.38883    |   0.0 |  1.15
Other   |            | 0.0661     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 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:      333122.0 ave      333122 max      333122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333122
Ave neighs/atom = 166.56100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.942789596793, Press = -1.89837900330602
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8048.6624   -8048.6624   -8114.7423   -8114.7423    255.73598    255.73598    21513.574    21513.574    838.95166    838.95166 
   39000   -8048.6771   -8048.6771   -8113.4441   -8113.4441    250.65518    250.65518    21533.046    21533.046   -27.880559   -27.880559 
Loop time of 32.4245 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.007 hours/ns, 30.841 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    | 31.857     | 31.857     | 31.857     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.39
Output  | 0.00015261 | 0.00015261 | 0.00015261 |   0.0 |  0.00
Modify  | 0.37577    | 0.37577    | 0.37577    |   0.0 |  1.16
Other   |            | 0.06554    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 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:      333148.0 ave      333148 max      333148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333148
Ave neighs/atom = 166.57400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937193253293, Press = -0.918270518163682
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8048.6771   -8048.6771   -8113.4441   -8113.4441    250.65518    250.65518    21533.046    21533.046   -27.880559   -27.880559 
   40000   -8052.3443   -8052.3443   -8116.7045   -8116.7045    249.08036    249.08036    21549.797    21549.797   -977.91797   -977.91797 
Loop time of 31.3088 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.697 hours/ns, 31.940 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    | 30.756     | 30.756     | 30.756     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12211    | 0.12211    | 0.12211    |   0.0 |  0.39
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.36424    | 0.36424    | 0.36424    |   0.0 |  1.16
Other   |            | 0.06599    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 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:      332750.0 ave      332750 max      332750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332750
Ave neighs/atom = 166.37500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.971471112633, Press = 0.709235583001963
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8052.3443   -8052.3443   -8116.7045   -8116.7045    249.08036    249.08036    21549.797    21549.797   -977.91797   -977.91797 
   41000   -8052.5719   -8052.5719   -8116.9862   -8116.9862    249.28987    249.28987    21521.094    21521.094     746.8719     746.8719 
Loop time of 32.8832 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.134 hours/ns, 30.411 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    | 32.31      | 32.31      | 32.31      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12703    | 0.12703    | 0.12703    |   0.0 |  0.39
Output  | 0.00015292 | 0.00015292 | 0.00015292 |   0.0 |  0.00
Modify  | 0.38007    | 0.38007    | 0.38007    |   0.0 |  1.16
Other   |            | 0.06597    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 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:      332516.0 ave      332516 max      332516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332516
Ave neighs/atom = 166.25800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.963493654146, Press = 1.09583607392659
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8052.5719   -8052.5719   -8116.9862   -8116.9862    249.28987    249.28987    21521.094    21521.094     746.8719     746.8719 
   42000   -8050.1995   -8050.1995   -8114.9503   -8114.9503    250.59225    250.59225    21556.076    21556.076   -1354.7945   -1354.7945 
Loop time of 32.8075 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.634 ns/day, 9.113 hours/ns, 30.481 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    | 32.233     | 32.233     | 32.233     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12818    | 0.12818    | 0.12818    |   0.0 |  0.39
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.37958    | 0.37958    | 0.37958    |   0.0 |  1.16
Other   |            | 0.0664     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      333222.0 ave      333222 max      333222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333222
Ave neighs/atom = 166.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.001635150569, Press = 0.360902529645592
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8050.1995   -8050.1995   -8114.9503   -8114.9503    250.59225    250.59225    21556.076    21556.076   -1354.7945   -1354.7945 
   43000   -8051.6122   -8051.6122    -8115.578    -8115.578    247.55448    247.55448    21573.989    21573.989   -3695.5618   -3695.5618 
Loop time of 34.1919 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.527 ns/day, 9.498 hours/ns, 29.247 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    | 33.596     | 33.596     | 33.596     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13119    | 0.13119    | 0.13119    |   0.0 |  0.38
Output  | 0.00015065 | 0.00015065 | 0.00015065 |   0.0 |  0.00
Modify  | 0.39742    | 0.39742    | 0.39742    |   0.0 |  1.16
Other   |            | 0.0666     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 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:      332466.0 ave      332466 max      332466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332466
Ave neighs/atom = 166.23300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.003971092446, Press = -1.01096584542396
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8051.6122   -8051.6122    -8115.578    -8115.578    247.55448    247.55448    21573.989    21573.989   -3695.5618   -3695.5618 
   44000   -8048.0531   -8048.0531   -8114.3321   -8114.3321    256.50681    256.50681     21555.63     21555.63   -1443.0819   -1443.0819 
Loop time of 32.1376 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.927 hours/ns, 31.116 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    | 31.57      | 31.57      | 31.57      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12521    | 0.12521    | 0.12521    |   0.0 |  0.39
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.37627    | 0.37627    | 0.37627    |   0.0 |  1.17
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      332134.0 ave      332134 max      332134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0