# 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.863657340407371*${_u_distance}
variable latticeconst_converted equal 2.863657340407371*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86365734040737
Lattice spacing in x,y,z = 2.8636573 2.8636573 2.8636573
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636573 28.636573 28.636573)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.636573 28.636573 28.636573)
  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 MEAM_LAMMPS_KimShinLee_2009_FeMn__MO_058735400462_002
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 23483.5175609808    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5175609808/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5175609808/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23483.5175609808/(1*1*${_u_distance})
variable      V0_metal equal 23483.5175609808/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23483.5175609808*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8493.9171     -8493.9171     -8580          -8580           333.15         333.15         23483.518      23483.518      3915.3602      3915.3602    
      1000  -8403.2191     -8403.2191     -8485.7345     -8485.7345      319.34322      319.34322      23777.874      23777.874     -774.30946     -774.30946    
Loop time of 94.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.915 ns/day, 26.236 hours/ns, 10.588 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.979     | 93.979     | 93.979     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073384   | 0.073384   | 0.073384   |   0.0 |  0.08
Output  | 0.00021622 | 0.00021622 | 0.00021622 |   0.0 |  0.00
Modify  | 0.33941    | 0.33941    | 0.33941    |   0.0 |  0.36
Other   |            | 0.05561    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8403.2191     -8403.2191     -8485.7345     -8485.7345      319.34322      319.34322      23777.874      23777.874     -774.30946     -774.30946    
      2000  -8404.1366     -8404.1366     -8488.8528     -8488.8528      327.86032      327.86032      23787.917      23787.917     -1855.3108     -1855.3108    
Loop time of 95.9233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.645 hours/ns, 10.425 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.462     | 95.462     | 95.462     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072102   | 0.072102   | 0.072102   |   0.0 |  0.08
Output  | 0.0002434  | 0.0002434  | 0.0002434  |   0.0 |  0.00
Modify  | 0.33293    | 0.33293    | 0.33293    |   0.0 |  0.35
Other   |            | 0.05577    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116986 ave      116986 max      116986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116986
Ave neighs/atom = 58.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8404.1366     -8404.1366     -8488.8528     -8488.8528      327.86032      327.86032      23787.917      23787.917     -1855.3108     -1855.3108    
      3000  -8405.2295     -8405.2295     -8486.2363     -8486.2363      313.50468      313.50468      23742.799      23742.799      1602.1027      1602.1027    
Loop time of 95.9939 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.665 hours/ns, 10.417 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.534     | 95.534     | 95.534     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072703   | 0.072703   | 0.072703   |   0.0 |  0.08
Output  | 0.0002091  | 0.0002091  | 0.0002091  |   0.0 |  0.00
Modify  | 0.33173    | 0.33173    | 0.33173    |   0.0 |  0.35
Other   |            | 0.05523    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116824 ave      116824 max      116824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116824
Ave neighs/atom = 58.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8405.2295     -8405.2295     -8486.2363     -8486.2363      313.50468      313.50468      23742.799      23742.799      1602.1027      1602.1027    
      4000  -8402.7949     -8402.7949     -8491.5321     -8491.5321      343.42246      343.42246      23735.915      23735.915      1545.7965      1545.7965    
Loop time of 95.9334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.648 hours/ns, 10.424 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.471     | 95.471     | 95.471     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072577   | 0.072577   | 0.072577   |   0.0 |  0.08
Output  | 0.00020739 | 0.00020739 | 0.00020739 |   0.0 |  0.00
Modify  | 0.33383    | 0.33383    | 0.33383    |   0.0 |  0.35
Other   |            | 0.05538    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2972 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116906 ave      116906 max      116906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116906
Ave neighs/atom = 58.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8402.7949     -8402.7949     -8491.5321     -8491.5321      343.42246      343.42246      23735.915      23735.915      1545.7965      1545.7965    
      5000  -8405.4713     -8405.4713     -8492.918      -8492.918       338.42746      338.42746      23775.81       23775.81      -1484.0279     -1484.0279    
Loop time of 95.8747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.632 hours/ns, 10.430 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.411     | 95.411     | 95.411     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07292    | 0.07292    | 0.07292    |   0.0 |  0.08
Output  | 0.00016807 | 0.00016807 | 0.00016807 |   0.0 |  0.00
Modify  | 0.33506    | 0.33506    | 0.33506    |   0.0 |  0.35
Other   |            | 0.05542    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116884 ave      116884 max      116884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116884
Ave neighs/atom = 58.442
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 = 332.271763731045, Press = -406.186639383158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8405.4713     -8405.4713     -8492.918      -8492.918       338.42746      338.42746      23775.81       23775.81      -1484.0279     -1484.0279    
      6000  -8403.0184     -8403.0184     -8490.2576     -8490.2576      337.62463      337.62463      23760.648      23760.648     -3.7148173     -3.7148173    
Loop time of 96.1327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.704 hours/ns, 10.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.652     | 95.652     | 95.652     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072651   | 0.072651   | 0.072651   |   0.0 |  0.08
Output  | 0.00016611 | 0.00016611 | 0.00016611 |   0.0 |  0.00
Modify  | 0.35317    | 0.35317    | 0.35317    |   0.0 |  0.37
Other   |            | 0.0551     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2961 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116752 ave      116752 max      116752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116752
Ave neighs/atom = 58.376
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 = 331.794216061294, Press = 13.0057102591213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8403.0184     -8403.0184     -8490.2576     -8490.2576      337.62463      337.62463      23760.648      23760.648     -3.7148173     -3.7148173    
      7000  -8404.0415     -8404.0415     -8490.7759     -8490.7759      335.67114      335.67114      23763.668      23763.668     -354.90252     -354.90252    
Loop time of 95.8348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.621 hours/ns, 10.435 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.353     | 95.353     | 95.353     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072708   | 0.072708   | 0.072708   |   0.0 |  0.08
Output  | 0.00016797 | 0.00016797 | 0.00016797 |   0.0 |  0.00
Modify  | 0.3536     | 0.3536     | 0.3536     |   0.0 |  0.37
Other   |            | 0.05554    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116794 ave      116794 max      116794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116794
Ave neighs/atom = 58.397
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 = 332.874100227258, Press = -16.3591272315833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8404.0415     -8404.0415     -8490.7759     -8490.7759      335.67114      335.67114      23763.668      23763.668     -354.90252     -354.90252    
      8000  -8401.1428     -8401.1428     -8488.6013     -8488.6013      338.47347      338.47347      23787.589      23787.589     -1671.7471     -1671.7471    
Loop time of 95.7553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.599 hours/ns, 10.443 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.273     | 95.273     | 95.273     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072461   | 0.072461   | 0.072461   |   0.0 |  0.08
Output  | 0.00020575 | 0.00020575 | 0.00020575 |   0.0 |  0.00
Modify  | 0.35403    | 0.35403    | 0.35403    |   0.0 |  0.37
Other   |            | 0.05557    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116828 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414
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 = 332.883625912602, Press = 7.3998166570474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8401.1428     -8401.1428     -8488.6013     -8488.6013      338.47347      338.47347      23787.589      23787.589     -1671.7471     -1671.7471    
      9000  -8405.1185     -8405.1185     -8487.9676     -8487.9676      320.63474      320.63474      23733.829      23733.829      2104.7604      2104.7604    
Loop time of 95.8494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.625 hours/ns, 10.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.368     | 95.368     | 95.368     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071966   | 0.071966   | 0.071966   |   0.0 |  0.08
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.35399    | 0.35399    | 0.35399    |   0.0 |  0.37
Other   |            | 0.05501    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2954 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116888 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444
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 = 332.864809708596, Press = 15.6011555279443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8405.1185     -8405.1185     -8487.9676     -8487.9676      320.63474      320.63474      23733.829      23733.829      2104.7604      2104.7604    
     10000  -8402.8072     -8402.8072     -8488.778      -8488.778       332.71606      332.71606      23733.922      23733.922      2009.2303      2009.2303    
Loop time of 96.0668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.685 hours/ns, 10.409 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.583     | 95.583     | 95.583     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072914   | 0.072914   | 0.072914   |   0.0 |  0.08
Output  | 0.00020551 | 0.00020551 | 0.00020551 |   0.0 |  0.00
Modify  | 0.35514    | 0.35514    | 0.35514    |   0.0 |  0.37
Other   |            | 0.05594    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2974 ave        2974 max        2974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116946 ave      116946 max      116946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116946
Ave neighs/atom = 58.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.020731828832, Press = -14.2592635124779
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8402.8072     -8402.8072     -8488.778      -8488.778       332.71606      332.71606      23733.922      23733.922      2009.2303      2009.2303    
     11000  -8404.0108     -8404.0108     -8490.2925     -8490.2925      333.91908      333.91908      23802.371      23802.371     -3030.3272     -3030.3272    
Loop time of 95.8593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.628 hours/ns, 10.432 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.377     | 95.377     | 95.377     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072931   | 0.072931   | 0.072931   |   0.0 |  0.08
Output  | 0.00016866 | 0.00016866 | 0.00016866 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.37
Other   |            | 0.05542    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2975 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116910 ave      116910 max      116910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116910
Ave neighs/atom = 58.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.110812094375, Press = -8.42949402791573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8404.0108     -8404.0108     -8490.2925     -8490.2925      333.91908      333.91908      23802.371      23802.371     -3030.3272     -3030.3272    
     12000  -8408.5074     -8408.5074     -8492.4204     -8492.4204      324.75224      324.75224      23755.357      23755.357     -161.20346     -161.20346    
Loop time of 95.8158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.616 hours/ns, 10.437 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.334     | 95.334     | 95.334     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072826   | 0.072826   | 0.072826   |   0.0 |  0.08
Output  | 0.00020896 | 0.00020896 | 0.00020896 |   0.0 |  0.00
Modify  | 0.35355    | 0.35355    | 0.35355    |   0.0 |  0.37
Other   |            | 0.05538    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116790 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395
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 = 332.803423165105, Press = 8.97283725078752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8408.5074     -8408.5074     -8492.4204     -8492.4204      324.75224      324.75224      23755.357      23755.357     -161.20346     -161.20346    
     13000  -8404.12       -8404.12       -8488.5906     -8488.5906      326.90978      326.90978      23742.675      23742.675      1447.3373      1447.3373    
Loop time of 95.8199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.617 hours/ns, 10.436 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.335     | 95.335     | 95.335     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073572   | 0.073572   | 0.073572   |   0.0 |  0.08
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.35521    | 0.35521    | 0.35521    |   0.0 |  0.37
Other   |            | 0.05575    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2975 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116842 ave      116842 max      116842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116842
Ave neighs/atom = 58.421
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 = 332.653344367097, Press = -1.73179694413804
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8404.12       -8404.12       -8488.5906     -8488.5906      326.90978      326.90978      23742.675      23742.675      1447.3373      1447.3373    
     14000  -8401.9263     -8401.9263     -8490.711      -8490.711       343.60609      343.60609      23776.697      23776.697     -1201.1108     -1201.1108    
Loop time of 95.9326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.648 hours/ns, 10.424 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.45      | 95.45      | 95.45      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072974   | 0.072974   | 0.072974   |   0.0 |  0.08
Output  | 0.00016948 | 0.00016948 | 0.00016948 |   0.0 |  0.00
Modify  | 0.35417    | 0.35417    | 0.35417    |   0.0 |  0.37
Other   |            | 0.05574    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116930 ave      116930 max      116930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116930
Ave neighs/atom = 58.465
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 = 332.715115377332, Press = -3.97503028772999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8401.9263     -8401.9263     -8490.711      -8490.711       343.60609      343.60609      23776.697      23776.697     -1201.1108     -1201.1108    
     15000  -8406.4963     -8406.4963     -8493.2863     -8493.2863      335.88655      335.88655      23770.821      23770.821     -1139.3751     -1139.3751    
Loop time of 95.9209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.645 hours/ns, 10.425 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.438     | 95.438     | 95.438     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072648   | 0.072648   | 0.072648   |   0.0 |  0.08
Output  | 0.00019767 | 0.00019767 | 0.00019767 |   0.0 |  0.00
Modify  | 0.35421    | 0.35421    | 0.35421    |   0.0 |  0.37
Other   |            | 0.05562    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116808 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404
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 = 332.566730511629, Press = 1.05202687591336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8406.4963     -8406.4963     -8493.2863     -8493.2863      335.88655      335.88655      23770.821      23770.821     -1139.3751     -1139.3751    
     16000  -8400.6861     -8400.6861     -8488.9115     -8488.9115      341.44114      341.44114      23722.388      23722.388      3080.8314      3080.8314    
Loop time of 95.8899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.636 hours/ns, 10.429 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.408     | 95.408     | 95.408     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072921   | 0.072921   | 0.072921   |   0.0 |  0.08
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.3537     | 0.3537     | 0.3537     |   0.0 |  0.37
Other   |            | 0.05544    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2960 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116790 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395
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 = 332.597738072717, Press = 5.07710526284324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8400.6861     -8400.6861     -8488.9115     -8488.9115      341.44114      341.44114      23722.388      23722.388      3080.8314      3080.8314    
     17000  -8402.071      -8402.071      -8488.2935     -8488.2935      333.69004      333.69004      23737.834      23737.834      1896.2221      1896.2221    
Loop time of 96.0092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.669 hours/ns, 10.416 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.528     | 95.528     | 95.528     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072944   | 0.072944   | 0.072944   |   0.0 |  0.08
Output  | 0.00018259 | 0.00018259 | 0.00018259 |   0.0 |  0.00
Modify  | 0.35279    | 0.35279    | 0.35279    |   0.0 |  0.37
Other   |            | 0.05527    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2961 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116998 ave      116998 max      116998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116998
Ave neighs/atom = 58.499
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 = 332.6840974641, Press = -8.65715974662355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8402.071      -8402.071      -8488.2935     -8488.2935      333.69004      333.69004      23737.834      23737.834      1896.2221      1896.2221    
     18000  -8404.6874     -8404.6874     -8491.4062     -8491.4062      335.61084      335.61084      23793.627      23793.627     -2640.8894     -2640.8894    
Loop time of 96.0135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.670 hours/ns, 10.415 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.533     | 95.533     | 95.533     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072777   | 0.072777   | 0.072777   |   0.0 |  0.08
Output  | 0.00016777 | 0.00016777 | 0.00016777 |   0.0 |  0.00
Modify  | 0.35267    | 0.35267    | 0.35267    |   0.0 |  0.37
Other   |            | 0.05509    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2969 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116914 ave      116914 max      116914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116914
Ave neighs/atom = 58.457
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 = 332.903053916427, Press = -2.31194996198508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8404.6874     -8404.6874     -8491.4062     -8491.4062      335.61084      335.61084      23793.627      23793.627     -2640.8894     -2640.8894    
     19000  -8399.128      -8399.128      -8486.7688     -8486.7688      339.17886      339.17886      23765.072      23765.072      244.79284      244.79284    
Loop time of 95.8462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.624 hours/ns, 10.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.364     | 95.364     | 95.364     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072887   | 0.072887   | 0.072887   |   0.0 |  0.08
Output  | 0.00020595 | 0.00020595 | 0.00020595 |   0.0 |  0.00
Modify  | 0.35413    | 0.35413    | 0.35413    |   0.0 |  0.37
Other   |            | 0.05522    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2956 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116802 ave      116802 max      116802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116802
Ave neighs/atom = 58.401
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.064135271085, Press = 4.01980669234838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8399.128      -8399.128      -8486.7688     -8486.7688      339.17886      339.17886      23765.072      23765.072      244.79284      244.79284    
     20000  -8403.7106     -8403.7106     -8491.3093     -8491.3093      339.0159       339.0159       23734.223      23734.223      1557.3505      1557.3505    
Loop time of 96.0311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.675 hours/ns, 10.413 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.548     | 95.548     | 95.548     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072861   | 0.072861   | 0.072861   |   0.0 |  0.08
Output  | 0.00016861 | 0.00016861 | 0.00016861 |   0.0 |  0.00
Modify  | 0.35439    | 0.35439    | 0.35439    |   0.0 |  0.37
Other   |            | 0.05588    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116876 ave      116876 max      116876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116876
Ave neighs/atom = 58.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.197412903871, Press = -1.10543234203039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8403.7106     -8403.7106     -8491.3093     -8491.3093      339.0159       339.0159       23734.223      23734.223      1557.3505      1557.3505    
     21000  -8404.8239     -8404.8239     -8489.5787     -8489.5787      328.00977      328.00977      23772.575      23772.575     -758.15077     -758.15077    
Loop time of 96.1399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.706 hours/ns, 10.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.657     | 95.657     | 95.657     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072945   | 0.072945   | 0.072945   |   0.0 |  0.08
Output  | 0.00016962 | 0.00016962 | 0.00016962 |   0.0 |  0.00
Modify  | 0.3547     | 0.3547     | 0.3547     |   0.0 |  0.37
Other   |            | 0.05542    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116956 ave      116956 max      116956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116956
Ave neighs/atom = 58.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152347724162, Press = -2.54779663529977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8404.8239     -8404.8239     -8489.5787     -8489.5787      328.00977      328.00977      23772.575      23772.575     -758.15077     -758.15077    
     22000  -8402.5985     -8402.5985     -8490.365      -8490.365       339.6655       339.6655       23778.576      23778.576     -1174.0083     -1174.0083    
Loop time of 95.8334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.620 hours/ns, 10.435 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.351     | 95.351     | 95.351     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072877   | 0.072877   | 0.072877   |   0.0 |  0.08
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.35454    | 0.35454    | 0.35454    |   0.0 |  0.37
Other   |            | 0.05524    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2972 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116888 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.077101526651, Press = 2.12136783213957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8402.5985     -8402.5985     -8490.365      -8490.365       339.6655       339.6655       23778.576      23778.576     -1174.0083     -1174.0083    
     23000  -8407.1233     -8407.1233     -8492.7553     -8492.7553      331.40451      331.40451      23720.392      23720.392      2353.9575      2353.9575    
Loop time of 96.2444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.735 hours/ns, 10.390 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.762     | 95.762     | 95.762     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072984   | 0.072984   | 0.072984   |   0.0 |  0.08
Output  | 0.00016793 | 0.00016793 | 0.00016793 |   0.0 |  0.00
Modify  | 0.35389    | 0.35389    | 0.35389    |   0.0 |  0.37
Other   |            | 0.05557    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2953 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116784 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392
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 = 332.957831789569, Press = 0.662581676571458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8407.1233     -8407.1233     -8492.7553     -8492.7553      331.40451      331.40451      23720.392      23720.392      2353.9575      2353.9575    
     24000  -8402.8037     -8402.8037     -8488.2051     -8488.2051      330.51247      330.51247      23769.997      23769.997     -384.98693     -384.98693    
Loop time of 95.8614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.628 hours/ns, 10.432 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.378     | 95.378     | 95.378     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072857   | 0.072857   | 0.072857   |   0.0 |  0.08
Output  | 0.00016706 | 0.00016706 | 0.00016706 |   0.0 |  0.00
Modify  | 0.35449    | 0.35449    | 0.35449    |   0.0 |  0.37
Other   |            | 0.05566    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2969 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116848 ave      116848 max      116848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116848
Ave neighs/atom = 58.424
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 = 332.920570183962, Press = -5.01284837751977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8402.8037     -8402.8037     -8488.2051     -8488.2051      330.51247      330.51247      23769.997      23769.997     -384.98693     -384.98693    
     25000  -8402.9566     -8402.9566     -8488.4693     -8488.4693      330.9427       330.9427       23798.359      23798.359     -2320.2681     -2320.2681    
Loop time of 96.2259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.729 hours/ns, 10.392 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.744     | 95.744     | 95.744     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072205   | 0.072205   | 0.072205   |   0.0 |  0.08
Output  | 0.0002049  | 0.0002049  | 0.0002049  |   0.0 |  0.00
Modify  | 0.35435    | 0.35435    | 0.35435    |   0.0 |  0.37
Other   |            | 0.05531    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2958 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116810 ave      116810 max      116810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116810
Ave neighs/atom = 58.405
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 = 332.928277692681, Press = 1.36085847920058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8402.9566     -8402.9566     -8488.4693     -8488.4693      330.9427       330.9427       23798.359      23798.359     -2320.2681     -2320.2681    
     26000  -8405.5239     -8405.5239     -8492.0391     -8492.0391      334.82269      334.82269      23736.42       23736.42       1359.9136      1359.9136    
Loop time of 95.9086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.641 hours/ns, 10.427 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.426     | 95.426     | 95.426     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072621   | 0.072621   | 0.072621   |   0.0 |  0.08
Output  | 0.0002     | 0.0002     | 0.0002     |   0.0 |  0.00
Modify  | 0.35441    | 0.35441    | 0.35441    |   0.0 |  0.37
Other   |            | 0.05545    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2956 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116804 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.090651253327, Press = 1.77496255763714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8405.5239     -8405.5239     -8492.0391     -8492.0391      334.82269      334.82269      23736.42       23736.42       1359.9136      1359.9136    
     27000  -8403.581      -8403.581      -8489.3666     -8489.3666      331.99922      331.99922      23745.134      23745.134      1165.8092      1165.8092    
Loop time of 96.0072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.669 hours/ns, 10.416 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.528     | 95.528     | 95.528     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072401   | 0.072401   | 0.072401   |   0.0 |  0.08
Output  | 0.0001681  | 0.0001681  | 0.0001681  |   0.0 |  0.00
Modify  | 0.35155    | 0.35155    | 0.35155    |   0.0 |  0.37
Other   |            | 0.05515    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116856 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152259304331, Press = -1.64651104320825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8403.581      -8403.581      -8489.3666     -8489.3666      331.99922      331.99922      23745.134      23745.134      1165.8092      1165.8092    
     28000  -8406.1283     -8406.1283     -8489.6756     -8489.6756      323.33665      323.33665      23758.977      23758.977     -2.8318935     -2.8318935    
Loop time of 95.8849 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.635 hours/ns, 10.429 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.4       | 95.4       | 95.4       |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072595   | 0.072595   | 0.072595   |   0.0 |  0.08
Output  | 0.00016588 | 0.00016588 | 0.00016588 |   0.0 |  0.00
Modify  | 0.3559     | 0.3559     | 0.3559     |   0.0 |  0.37
Other   |            | 0.05621    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116950 ave      116950 max      116950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116950
Ave neighs/atom = 58.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.20671501114, Press = -0.693019874578679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8406.1283     -8406.1283     -8489.6756     -8489.6756      323.33665      323.33665      23758.977      23758.977     -2.8318935     -2.8318935    
     29000  -8400.4649     -8400.4649     -8487.1265     -8487.1265      335.38928      335.38928      23761.555      23761.555      541.60623      541.60623    
Loop time of 95.7798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.606 hours/ns, 10.441 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.296     | 95.296     | 95.296     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073035   | 0.073035   | 0.073035   |   0.0 |  0.08
Output  | 0.00016799 | 0.00016799 | 0.00016799 |   0.0 |  0.00
Modify  | 0.35501    | 0.35501    | 0.35501    |   0.0 |  0.37
Other   |            | 0.0553     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116916 ave      116916 max      116916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116916
Ave neighs/atom = 58.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.218002480355, Press = -0.621055059093185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8400.4649     -8400.4649     -8487.1265     -8487.1265      335.38928      335.38928      23761.555      23761.555      541.60623      541.60623    
     30000  -8404.5072     -8404.5072     -8491.5316     -8491.5316      336.79348      336.79348      23769.412      23769.412     -903.95419     -903.95419    
Loop time of 96.0179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.672 hours/ns, 10.415 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.534     | 95.534     | 95.534     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07243    | 0.07243    | 0.07243    |   0.0 |  0.08
Output  | 0.00016799 | 0.00016799 | 0.00016799 |   0.0 |  0.00
Modify  | 0.35538    | 0.35538    | 0.35538    |   0.0 |  0.37
Other   |            | 0.05613    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2963 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116808 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.323170942594, Press = -1.02656581401725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8404.5072     -8404.5072     -8491.5316     -8491.5316      336.79348      336.79348      23769.412      23769.412     -903.95419     -903.95419    
     31000  -8399.8158     -8399.8158     -8485.7363     -8485.7363      332.52136      332.52136      23794          23794         -1556.36       -1556.36      
Loop time of 95.9754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.660 hours/ns, 10.419 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.493     | 95.493     | 95.493     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072635   | 0.072635   | 0.072635   |   0.0 |  0.08
Output  | 0.00016953 | 0.00016953 | 0.00016953 |   0.0 |  0.00
Modify  | 0.35399    | 0.35399    | 0.35399    |   0.0 |  0.37
Other   |            | 0.05522    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2960 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116852 ave      116852 max      116852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116852
Ave neighs/atom = 58.426
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.368114850843, Press = 1.06973527630848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8399.8158     -8399.8158     -8485.7363     -8485.7363      332.52136      332.52136      23794          23794         -1556.36       -1556.36      
     32000  -8404.0534     -8404.0534     -8491.8045     -8491.8045      339.60586      339.60586      23725.948      23725.948      2194.043       2194.043     
Loop time of 95.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.552 hours/ns, 10.462 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.103     | 95.103     | 95.103     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072919   | 0.072919   | 0.072919   |   0.0 |  0.08
Output  | 0.00016717 | 0.00016717 | 0.00016717 |   0.0 |  0.00
Modify  | 0.35447    | 0.35447    | 0.35447    |   0.0 |  0.37
Other   |            | 0.05548    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2970 ave        2970 max        2970 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116804 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.312819128286, Press = 1.76566807829897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8404.0534     -8404.0534     -8491.8045     -8491.8045      339.60586      339.60586      23725.948      23725.948      2194.043       2194.043     
     33000  -8402.8575     -8402.8575     -8488.7948     -8488.7948      332.58627      332.58627      23738.7        23738.7        1757.0391      1757.0391    
Loop time of 95.9284 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.647 hours/ns, 10.424 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.446     | 95.446     | 95.446     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072727   | 0.072727   | 0.072727   |   0.0 |  0.08
Output  | 0.00016811 | 0.00016811 | 0.00016811 |   0.0 |  0.00
Modify  | 0.35365    | 0.35365    | 0.35365    |   0.0 |  0.37
Other   |            | 0.05608    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2977 ave        2977 max        2977 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116892 ave      116892 max      116892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116892
Ave neighs/atom = 58.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.247961610695, Press = -2.43222421705099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8402.8575     -8402.8575     -8488.7948     -8488.7948      332.58627      332.58627      23738.7        23738.7        1757.0391      1757.0391    
     34000  -8404.1981     -8404.1981     -8489.7843     -8489.7843      331.22743      331.22743      23781.148      23781.148     -1414.1586     -1414.1586    
Loop time of 95.8393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.622 hours/ns, 10.434 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.356     | 95.356     | 95.356     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072836   | 0.072836   | 0.072836   |   0.0 |  0.08
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.35398    | 0.35398    | 0.35398    |   0.0 |  0.37
Other   |            | 0.05605    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2973 ave        2973 max        2973 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116952 ave      116952 max      116952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116952
Ave neighs/atom = 58.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.145939025914, Press = -1.74103572622085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8404.1981     -8404.1981     -8489.7843     -8489.7843      331.22743      331.22743      23781.148      23781.148     -1414.1586     -1414.1586    
     35000  -8406.1654     -8406.1654     -8491.4541     -8491.4541      330.07603      330.07603      23769.715      23769.715     -967.72694     -967.72694    
Loop time of 95.7202 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.589 hours/ns, 10.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.237     | 95.237     | 95.237     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072459   | 0.072459   | 0.072459   |   0.0 |  0.08
Output  | 0.00016838 | 0.00016838 | 0.00016838 |   0.0 |  0.00
Modify  | 0.35535    | 0.35535    | 0.35535    |   0.0 |  0.37
Other   |            | 0.0553     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2966 ave        2966 max        2966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116800 ave      116800 max      116800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116800
Ave neighs/atom = 58.4
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.107364259283, Press = 0.72779226937211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8406.1654     -8406.1654     -8491.4541     -8491.4541      330.07603      330.07603      23769.715      23769.715     -967.72694     -967.72694    
     36000  -8401.3413     -8401.3413     -8488.8992     -8488.8992      338.8579       338.8579       23736.285      23736.285      2036.1749      2036.1749    
Loop time of 95.8135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.615 hours/ns, 10.437 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.33      | 95.33      | 95.33      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072845   | 0.072845   | 0.072845   |   0.0 |  0.08
Output  | 0.00016809 | 0.00016809 | 0.00016809 |   0.0 |  0.00
Modify  | 0.35493    | 0.35493    | 0.35493    |   0.0 |  0.37
Other   |            | 0.05544    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2972 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116860 ave      116860 max      116860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116860
Ave neighs/atom = 58.43
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.173368109058, Press = -0.445104975263616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8401.3413     -8401.3413     -8488.8992     -8488.8992      338.8579       338.8579       23736.285      23736.285      2036.1749      2036.1749    
     37000  -8405.0409     -8405.0409     -8488.36       -8488.36        322.45359      322.45359      23771.219      23771.219     -604.60701     -604.60701    
Loop time of 95.6588 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.572 hours/ns, 10.454 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.176     | 95.176     | 95.176     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072268   | 0.072268   | 0.072268   |   0.0 |  0.08
Output  | 0.00016992 | 0.00016992 | 0.00016992 |   0.0 |  0.00
Modify  | 0.35444    | 0.35444    | 0.35444    |   0.0 |  0.37
Other   |            | 0.05604    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116898 ave      116898 max      116898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116898
Ave neighs/atom = 58.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.233348561595, Press = -2.72012012682172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8405.0409     -8405.0409     -8488.36       -8488.36        322.45359      322.45359      23771.219      23771.219     -604.60701     -604.60701    
     38000  -8399.951      -8399.951      -8485.9897     -8485.9897      332.97846      332.97846      23818.753      23818.753     -3484.1477     -3484.1477    
Loop time of 95.6181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.561 hours/ns, 10.458 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.135     | 95.135     | 95.135     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072918   | 0.072918   | 0.072918   |   0.0 |  0.08
Output  | 0.00047606 | 0.00047606 | 0.00047606 |   0.0 |  0.00
Modify  | 0.3546     | 0.3546     | 0.3546     |   0.0 |  0.37
Other   |            | 0.05531    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2964 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116944 ave      116944 max      116944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116944
Ave neighs/atom = 58.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.323808539669, Press = 1.72499954803179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8399.951      -8399.951      -8485.9897     -8485.9897      332.97846      332.97846      23818.753      23818.753     -3484.1477     -3484.1477    
     39000  -8402.4727     -8402.4727     -8488.7587     -8488.7587      333.93563      333.93563      23733.753      23733.753      2098.5687      2098.5687    
Loop time of 95.7447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.596 hours/ns, 10.444 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.261     | 95.261     | 95.261     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073153   | 0.073153   | 0.073153   |   0.0 |  0.08
Output  | 0.00016852 | 0.00016852 | 0.00016852 |   0.0 |  0.00
Modify  | 0.35448    | 0.35448    | 0.35448    |   0.0 |  0.37
Other   |            | 0.05588    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2958 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116846 ave      116846 max      116846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116846
Ave neighs/atom = 58.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.340256655704, Press = 1.2131046548307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8402.4727     -8402.4727     -8488.7587     -8488.7587      333.93563      333.93563      23733.753      23733.753      2098.5687      2098.5687    
     40000  -8409.2227     -8409.2227     -8492.9581     -8492.9581      324.06458      324.06458      23736.009      23736.009      1290.8991      1290.8991    
Loop time of 95.6644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.573 hours/ns, 10.453 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.182     | 95.182     | 95.182     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072952   | 0.072952   | 0.072952   |   0.0 |  0.08
Output  | 0.00020331 | 0.00020331 | 0.00020331 |   0.0 |  0.00
Modify  | 0.35372    | 0.35372    | 0.35372    |   0.0 |  0.37
Other   |            | 0.0555     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2959 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116942 ave      116942 max      116942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116942
Ave neighs/atom = 58.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.295569448958, Press = -1.88628752984218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8409.2227     -8409.2227     -8492.9581     -8492.9581      324.06458      324.06458      23736.009      23736.009      1290.8991      1290.8991    
     41000  -8402.7755     -8402.7755     -8489.9816     -8489.9816      337.49642      337.49642      23793.895      23793.895     -2300.5151     -2300.5151    
Loop time of 95.7357 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.593 hours/ns, 10.445 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.253     | 95.253     | 95.253     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072998   | 0.072998   | 0.072998   |   0.0 |  0.08
Output  | 0.00016749 | 0.00016749 | 0.00016749 |   0.0 |  0.00
Modify  | 0.35381    | 0.35381    | 0.35381    |   0.0 |  0.37
Other   |            | 0.05565    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2962 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116838 ave      116838 max      116838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116838
Ave neighs/atom = 58.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.236011755524, Press = -0.526641261879355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8402.7755     -8402.7755     -8489.9816     -8489.9816      337.49642      337.49642      23793.895      23793.895     -2300.5151     -2300.5151    
     42000  -8404.3402     -8404.3402     -8490.4421     -8490.4421      333.22356      333.22356      23759.027      23759.027     -31.951628     -31.951628    
Loop time of 95.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.593 hours/ns, 10.445 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.253     | 95.253     | 95.253     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072891   | 0.072891   | 0.072891   |   0.0 |  0.08
Output  | 0.00017002 | 0.00017002 | 0.00017002 |   0.0 |  0.00
Modify  | 0.3536     | 0.3536     | 0.3536     |   0.0 |  0.37
Other   |            | 0.05588    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2957 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116856 ave      116856 max      116856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116856
Ave neighs/atom = 58.428
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.238962722794, Press = 1.07531666059152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8404.3402     -8404.3402     -8490.4421     -8490.4421      333.22356      333.22356      23759.027      23759.027     -31.951628     -31.951628    
     43000  -8404.4806     -8404.4806     -8490.2216     -8490.2216      331.82656      331.82656      23707.816      23707.816      3759.2389      3759.2389    
Loop time of 95.7998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.611 hours/ns, 10.438 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.316     | 95.316     | 95.316     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073003   | 0.073003   | 0.073003   |   0.0 |  0.08
Output  | 0.00016771 | 0.00016771 | 0.00016771 |   0.0 |  0.00
Modify  | 0.35429    | 0.35429    | 0.35429    |   0.0 |  0.37
Other   |            | 0.05593    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2965 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116866 ave      116866 max      116866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116866
Ave neighs/atom = 58.433
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.184954546524, Press = -0.918362056293156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8404.4806     -8404.4806     -8490.2216     -8490.2216      331.82656      331.82656      23707.816      23707.816      3759.2389      3759.2389    
     44000  -8404.0833     -8404.0833     -8491.0819     -8491.0819      336.69353      336.69353      23799.182      23799.182     -2660.7895     -2660.7895    
Loop time of 95.9273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.646 hours/ns, 10.425 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.444     | 95.444     | 95.444     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073258   | 0.073258   | 0.073258   |   0.0 |  0.08
Output  | 0.0002103  | 0.0002103  | 0.0002103  |   0.0 |  0.00
Modify  | 0.3539     | 0.3539     | 0.3539     |   0.0 |  0.37
Other   |            | 0.05546    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2960 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116918 ave      116918 max      116918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116918
Ave neighs/atom = 58.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.223900044087, Press = -3.60457184271936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8404.0833     -8404.0833     -8491.0819     -8491.0819      336.69353      336.69353      23799.182      23799.182     -2660.7895     -2660.7895    
     45000  -8401.1496     -8401.1496     -8487.8361     -8487.8361      335.48545      335.48545      23784.117      23784.117     -1182.8152     -1182.8152    
Loop time of 95.8256 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.618 hours/ns, 10.436 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.343     | 95.343     | 95.343     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07319    | 0.07319    | 0.07319    |   0.0 |  0.08
Output  | 0.00016669 | 0.00016669 | 0.00016669 |   0.0 |  0.00
Modify  | 0.35386    | 0.35386    | 0.35386    |   0.0 |  0.37
Other   |            | 0.05524    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2964 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116750 ave      116750 max      116750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116750
Ave neighs/atom = 58.375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.214408679394, Press = 0.653945235045892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8401.1496     -8401.1496     -8487.8361     -8487.8361      335.48545      335.48545      23784.117      23784.117     -1182.8152     -1182.8152    
     46000  -8404.9828     -8404.9828     -8489.5779     -8489.5779      327.39153      327.39153      23740.194      23740.194      1547.0408      1547.0408    
Loop time of 95.8535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.626 hours/ns, 10.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.37      | 95.37      | 95.37      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074286   | 0.074286   | 0.074286   |   0.0 |  0.08
Output  | 0.0002105  | 0.0002105  | 0.0002105  |   0.0 |  0.00
Modify  | 0.3532     | 0.3532     | 0.3532     |   0.0 |  0.37
Other   |            | 0.05541    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2972 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116844 ave      116844 max      116844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116844
Ave neighs/atom = 58.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.281497981771, Press = 0.342558046518955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8404.9828     -8404.9828     -8489.5779     -8489.5779      327.39153      327.39153      23740.194      23740.194      1547.0408      1547.0408    
     47000  -8400.9206     -8400.9206     -8490.6119     -8490.6119      347.1144       347.1144       23765.082      23765.082     -371.24991     -371.24991    
Loop time of 95.7015 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.584 hours/ns, 10.449 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.219     | 95.219     | 95.219     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07239    | 0.07239    | 0.07239    |   0.0 |  0.08
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.35438    | 0.35438    | 0.35438    |   0.0 |  0.37
Other   |            | 0.05573    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116902 ave      116902 max      116902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116902
Ave neighs/atom = 58.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.301329951197, Press = -1.57744195484754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8400.9206     -8400.9206     -8490.6119     -8490.6119      347.1144       347.1144       23765.082      23765.082     -371.24991     -371.24991    
     48000  -8406.9613     -8406.9613     -8492.5113     -8492.5113      331.08755      331.08755      23799.735      23799.735     -3252.2566     -3252.2566    
Loop time of 95.7076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.585 hours/ns, 10.448 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.224     | 95.224     | 95.224     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073692   | 0.073692   | 0.073692   |   0.0 |  0.08
Output  | 0.00016955 | 0.00016955 | 0.00016955 |   0.0 |  0.00
Modify  | 0.35409    | 0.35409    | 0.35409    |   0.0 |  0.37
Other   |            | 0.05589    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2967 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116818 ave      116818 max      116818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0