# 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.8809778466820717*${_u_distance} variable latticeconst_converted equal 2.8809778466820717*1 lattice bcc ${latticeconst_converted} lattice bcc 2.88097784668207 Lattice spacing in x,y,z = 2.8809778 2.8809778 2.8809778 region simbox block 0 10 0 10 0 10 units lattice create_box 1 simbox Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.809778 28.809778 28.809778) 1 by 1 by 1 MPI processor grid create_atoms 1 box Created 2000 atoms using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.809778 28.809778 28.809778) create_atoms CPU = 0.003 seconds variable mass_converted equal 51.9961*${_u_mass} variable mass_converted equal 51.9961*1 kim_interactions Cr WARNING: 'kim_' has been renamed to 'kim '. Please update your input. kim interactions Cr #=== BEGIN kim interactions ================================== pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Cr__MO_134550636109_000 pair_coeff * * Cr #=== END kim interactions ==================================== mass 1 ${mass_converted} mass 1 51.9961 # initial volume variable v equal vol # assign formula variable V0 equal ${v} # evaluate initial value variable V0 equal 23912.2122169252 variable V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance}) variable V0_metal equal 23912.2122169252/(${_u_distance}*${_u_distance}*${_u_distance}) variable V0_metal equal 23912.2122169252/(1*${_u_distance}*${_u_distance}) variable V0_metal equal 23912.2122169252/(1*1*${_u_distance}) variable V0_metal equal 23912.2122169252/(1*1*1) variable V0_metal_times1000 equal ${V0_metal}*1000 variable V0_metal_times1000 equal 23912.2122169252*1000 print "Initial system volume: ${V0_metal} Angstroms^3" Initial system volume: 23912.2122169252 Angstroms^3 # set the time step to 0.001 picoseconds variable timestep_converted equal 0.001*${_u_time} variable timestep_converted equal 0.001*1 timestep ${timestep_converted} timestep 0.001 variable temp_converted equal 293.15*${_u_temperature} variable temp_converted equal 293.15*1 variable Tdamp_converted equal 0.1*${_u_time} variable Tdamp_converted equal 0.1*1 variable press_converted equal 0.0*${_u_pressure} variable press_converted equal 0.0*1 variable Pdamp_converted equal 1*${_u_time} variable Pdamp_converted equal 1*1 # create initial velocities consistent with the chosen temperature velocity all create ${temp_converted} 17 mom yes rot yes velocity all create 293.15 17 mom yes rot yes # set NPT ensemble for all atoms fix ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted} iso ${press_converted} ${press_converted} ${Pdamp_converted} fix ensemble all npt temp 293.15 ${temp_converted} ${Tdamp_converted} iso ${press_converted} ${press_converted} ${Pdamp_converted} fix ensemble all npt temp 293.15 293.15 ${Tdamp_converted} iso ${press_converted} ${press_converted} ${Pdamp_converted} fix ensemble all npt temp 293.15 293.15 0.1 iso ${press_converted} ${press_converted} ${Pdamp_converted} fix ensemble all npt temp 293.15 293.15 0.1 iso 0 ${press_converted} ${Pdamp_converted} fix ensemble all npt temp 293.15 293.15 0.1 iso 0 0 ${Pdamp_converted} fix ensemble all npt temp 293.15 293.15 0.1 iso 0 0 1 # compute the time averages of pressure, temperature, and volume, respectively # ignore the first 5000 timesteps variable etotal_metal equal etotal/${_u_energy} variable etotal_metal equal etotal/1 variable pe_metal equal pe/${_u_energy} variable pe_metal equal pe/1 variable T_metal equal temp/${_u_temperature} variable T_metal equal temp/1 variable V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance}) variable V_metal equal vol/(1*${_u_distance}*${_u_distance}) variable V_metal equal vol/(1*1*${_u_distance}) variable V_metal equal vol/(1*1*1) variable P_metal equal press/${_u_pressure} variable P_metal equal press/1 fix avgmyTemp all ave/time 5 20 100 v_T_metal ave running start 5000 fix avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000 fix avgmyVol all ave/time 5 20 100 v_V_metal ave running start 5000 # extract fix quantities into variables so they can be used in if-else logic later. variable T equal f_avgmyTemp variable P equal f_avgmyPress variable V equal f_avgmyVol # set error bounds for temperature and pressure in original metal units (K and bar) variable T_low equal "293.15 - 0.2" variable T_up equal "293.15 + 0.2" variable P_low equal "0.0 - 0.2" variable P_up equal "0.0 + 0.2" # print to logfile every 1000 timesteps thermo_style custom step etotal v_etotal_metal pe v_pe_metal temp v_T_metal vol v_V_metal press v_P_metal thermo 1000 # Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check # whether the temperature and pressure have converged. If yes, break. label top variable a loop 2000 run 1000 CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE Your simulation uses code contributions which should be cited: - OpenKIM: https://doi.org/10.1007/s11837-011-0102-6 @Article{tadmor:elliott:2011, author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker}, title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels}, journal = {{JOM}}, year = 2011, volume = 63, number = 17, pages = {17}, doi = {10.1007/s11837-011-0102-6} } - OpenKIM potential: https://openkim.org/cite/MO_134550636109_000#item-citation CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8124.2527 -8124.2527 -8200 -8200 293.15 293.15 23912.212 23912.212 3383.4945 3383.4945 1000 -8042.8274 -8042.8274 -8121.8998 -8121.8998 306.01823 306.01823 24118.32 24118.32 -2371.9585 -2371.9585 Loop time of 98.1452 on 1 procs for 1000 steps with 2000 atoms Performance: 0.880 ns/day, 27.263 hours/ns, 10.189 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 97.641 | 97.641 | 97.641 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.080598 | 0.080598 | 0.080598 | 0.0 | 0.08 Output | 0.0001961 | 0.0001961 | 0.0001961 | 0.0 | 0.00 Modify | 0.36503 | 0.36503 | 0.36503 | 0.0 | 0.37 Other | | 0.05863 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116000.0 ave 116000 max 116000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116000 Ave neighs/atom = 58.000000 Neighbor list builds = 0 Dangerous builds = 0 if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable" if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break" print "flag: Temp = ${T}, Press = ${P}" flag: Temp = 0, Press = 0 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.8274 -8042.8274 -8121.8998 -8121.8998 306.01823 306.01823 24118.32 24118.32 -2371.9585 -2371.9585 2000 -8044.0226 -8044.0226 -8118.8408 -8118.8408 289.55417 289.55417 24067.574 24067.574 1235.9301 1235.9301 Loop time of 99.8577 on 1 procs for 1000 steps with 2000 atoms Performance: 0.865 ns/day, 27.738 hours/ns, 10.014 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.37 | 99.37 | 99.37 | 0.0 | 99.51 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076317 | 0.076317 | 0.076317 | 0.0 | 0.08 Output | 0.00019167 | 0.00019167 | 0.00019167 | 0.0 | 0.00 Modify | 0.35386 | 0.35386 | 0.35386 | 0.0 | 0.35 Other | | 0.05729 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2949.00 ave 2949 max 2949 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116140.0 ave 116140 max 116140 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116140 Ave neighs/atom = 58.070000 Neighbor list builds = 0 Dangerous builds = 0 if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable" if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break" print "flag: Temp = ${T}, Press = ${P}" flag: Temp = 0, Press = 0 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.0226 -8044.0226 -8118.8408 -8118.8408 289.55417 289.55417 24067.574 24067.574 1235.9301 1235.9301 3000 -8044.719 -8044.719 -8117.0888 -8117.0888 280.0785 280.0785 24105.587 24105.587 -1423.323 -1423.323 Loop time of 100.558 on 1 procs for 1000 steps with 2000 atoms Performance: 0.859 ns/day, 27.933 hours/ns, 9.944 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.07 | 100.07 | 100.07 | 0.0 | 99.51 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076072 | 0.076072 | 0.076072 | 0.0 | 0.08 Output | 0.00018494 | 0.00018494 | 0.00018494 | 0.0 | 0.00 Modify | 0.35544 | 0.35544 | 0.35544 | 0.0 | 0.35 Other | | 0.05761 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2947.00 ave 2947 max 2947 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116224.0 ave 116224 max 116224 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116224 Ave neighs/atom = 58.112000 Neighbor list builds = 0 Dangerous builds = 0 if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable" if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break" print "flag: Temp = ${T}, Press = ${P}" flag: Temp = 0, Press = 0 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.719 -8044.719 -8117.0888 -8117.0888 280.0785 280.0785 24105.587 24105.587 -1423.323 -1423.323 4000 -8043.0294 -8043.0294 -8119.6408 -8119.6408 296.49418 296.49418 24061.937 24061.937 1908.989 1908.989 Loop time of 98.5001 on 1 procs for 1000 steps with 2000 atoms Performance: 0.877 ns/day, 27.361 hours/ns, 10.152 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.022 | 98.022 | 98.022 | 0.0 | 99.51 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075111 | 0.075111 | 0.075111 | 0.0 | 0.08 Output | 0.00017934 | 0.00017934 | 0.00017934 | 0.0 | 0.00 Modify | 0.34587 | 0.34587 | 0.34587 | 0.0 | 0.35 Other | | 0.057 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 Neighbor list builds = 0 Dangerous builds = 0 if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable" if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break" print "flag: Temp = ${T}, Press = ${P}" flag: Temp = 0, Press = 0 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.0294 -8043.0294 -8119.6408 -8119.6408 296.49418 296.49418 24061.937 24061.937 1908.989 1908.989 5000 -8045.0277 -8045.0277 -8124.0092 -8124.0092 305.66673 305.66673 24124.13 24124.13 -3315.411 -3315.411 Loop time of 99.5378 on 1 procs for 1000 steps with 2000 atoms Performance: 0.868 ns/day, 27.649 hours/ns, 10.046 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.054 | 99.054 | 99.054 | 0.0 | 99.51 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075275 | 0.075275 | 0.075275 | 0.0 | 0.08 Output | 0.00015361 | 0.00015361 | 0.00015361 | 0.0 | 0.00 Modify | 0.35166 | 0.35166 | 0.35166 | 0.0 | 0.35 Other | | 0.05682 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116236.0 ave 116236 max 116236 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116236 Ave neighs/atom = 58.118000 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 = 292.79580567948, Press = 2148.15240845576 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8045.0277 -8045.0277 -8124.0092 -8124.0092 305.66673 305.66673 24124.13 24124.13 -3315.411 -3315.411 6000 -8042.8602 -8042.8602 -8117.9177 -8117.9177 290.48032 290.48032 24076.795 24076.795 880.38139 880.38139 Loop time of 100.667 on 1 procs for 1000 steps with 2000 atoms Performance: 0.858 ns/day, 27.963 hours/ns, 9.934 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.16 | 100.16 | 100.16 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076756 | 0.076756 | 0.076756 | 0.0 | 0.08 Output | 0.00015326 | 0.00015326 | 0.00015326 | 0.0 | 0.00 Modify | 0.37514 | 0.37514 | 0.37514 | 0.0 | 0.37 Other | | 0.05781 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116162.0 ave 116162 max 116162 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116162 Ave neighs/atom = 58.081000 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 = 292.643367355729, Press = 60.4061924791895 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.8602 -8042.8602 -8117.9177 -8117.9177 290.48032 290.48032 24076.795 24076.795 880.38139 880.38139 7000 -8045.7127 -8045.7127 -8120.8099 -8120.8099 290.63357 290.63357 24074.134 24074.134 680.22539 680.22539 Loop time of 103.382 on 1 procs for 1000 steps with 2000 atoms Performance: 0.836 ns/day, 28.717 hours/ns, 9.673 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 102.86 | 102.86 | 102.86 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.078215 | 0.078215 | 0.078215 | 0.0 | 0.08 Output | 0.00019418 | 0.00019418 | 0.00019418 | 0.0 | 0.00 Modify | 0.3889 | 0.3889 | 0.3889 | 0.0 | 0.38 Other | | 0.05879 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116226.0 ave 116226 max 116226 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116226 Ave neighs/atom = 58.113000 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 = 293.256416146101, Press = 81.1098726647249 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8045.7127 -8045.7127 -8120.8099 -8120.8099 290.63357 290.63357 24074.134 24074.134 680.22539 680.22539 8000 -8040.8687 -8040.8687 -8119.3257 -8119.3257 303.63673 303.63673 24106.641 24106.641 -1549.9398 -1549.9398 Loop time of 102.1 on 1 procs for 1000 steps with 2000 atoms Performance: 0.846 ns/day, 28.361 hours/ns, 9.794 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 101.58 | 101.58 | 101.58 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077964 | 0.077964 | 0.077964 | 0.0 | 0.08 Output | 0.00014991 | 0.00014991 | 0.00014991 | 0.0 | 0.00 Modify | 0.38397 | 0.38397 | 0.38397 | 0.0 | 0.38 Other | | 0.05822 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116202.0 ave 116202 max 116202 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116202 Ave neighs/atom = 58.101000 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 = 293.664425660947, Press = 27.0437651106569 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8040.8687 -8040.8687 -8119.3257 -8119.3257 303.63673 303.63673 24106.641 24106.641 -1549.9398 -1549.9398 9000 -8044.286 -8044.286 -8118.8165 -8118.8165 288.44084 288.44084 24065.142 24065.142 1605.3712 1605.3712 Loop time of 100.673 on 1 procs for 1000 steps with 2000 atoms Performance: 0.858 ns/day, 27.965 hours/ns, 9.933 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.16 | 100.16 | 100.16 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077154 | 0.077154 | 0.077154 | 0.0 | 0.08 Output | 0.00015658 | 0.00015658 | 0.00015658 | 0.0 | 0.00 Modify | 0.37732 | 0.37732 | 0.37732 | 0.0 | 0.37 Other | | 0.05834 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116208.0 ave 116208 max 116208 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116208 Ave neighs/atom = 58.104000 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 = 293.919247389973, Press = 35.9643911861446 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.286 -8044.286 -8118.8165 -8118.8165 288.44084 288.44084 24065.142 24065.142 1605.3712 1605.3712 10000 -8042.539 -8042.539 -8118.4382 -8118.4382 293.73766 293.73766 24130.952 24130.952 -3284.3225 -3284.3225 Loop time of 101.668 on 1 procs for 1000 steps with 2000 atoms Performance: 0.850 ns/day, 28.241 hours/ns, 9.836 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 101.15 | 101.15 | 101.15 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077099 | 0.077099 | 0.077099 | 0.0 | 0.08 Output | 0.00018814 | 0.00018814 | 0.00018814 | 0.0 | 0.00 Modify | 0.37946 | 0.37946 | 0.37946 | 0.0 | 0.37 Other | | 0.05807 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116198.0 ave 116198 max 116198 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116198 Ave neighs/atom = 58.099000 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 = 294.329222328581, Press = 14.0674497357613 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.539 -8042.539 -8118.4382 -8118.4382 293.73766 293.73766 24130.952 24130.952 -3284.3225 -3284.3225 11000 -8042.3212 -8042.3212 -8118.3845 -8118.3845 294.37267 294.37267 24036.03 24036.03 4018.7751 4018.7751 Loop time of 100.869 on 1 procs for 1000 steps with 2000 atoms Performance: 0.857 ns/day, 28.019 hours/ns, 9.914 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.36 | 100.36 | 100.36 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076447 | 0.076447 | 0.076447 | 0.0 | 0.08 Output | 0.0002654 | 0.0002654 | 0.0002654 | 0.0 | 0.00 Modify | 0.37476 | 0.37476 | 0.37476 | 0.0 | 0.37 Other | | 0.05798 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116174.0 ave 116174 max 116174 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116174 Ave neighs/atom = 58.087000 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 = 294.256103265516, Press = 25.5431208562912 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.3212 -8042.3212 -8118.3845 -8118.3845 294.37267 294.37267 24036.03 24036.03 4018.7751 4018.7751 12000 -8047.6124 -8047.6124 -8121.2649 -8121.2649 285.04282 285.04282 24118.739 24118.739 -2806.6956 -2806.6956 Loop time of 101.278 on 1 procs for 1000 steps with 2000 atoms Performance: 0.853 ns/day, 28.133 hours/ns, 9.874 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.77 | 100.77 | 100.77 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077144 | 0.077144 | 0.077144 | 0.0 | 0.08 Output | 0.00015768 | 0.00015768 | 0.00015768 | 0.0 | 0.00 Modify | 0.3773 | 0.3773 | 0.3773 | 0.0 | 0.37 Other | | 0.05831 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116250.0 ave 116250 max 116250 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116250 Ave neighs/atom = 58.125000 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 = 293.888730584974, Press = 17.1997758537196 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8047.6124 -8047.6124 -8121.2649 -8121.2649 285.04282 285.04282 24118.739 24118.739 -2806.6956 -2806.6956 13000 -8042.8912 -8042.8912 -8118.2416 -8118.2416 291.6138 291.6138 24053.593 24053.593 2662.7221 2662.7221 Loop time of 100.164 on 1 procs for 1000 steps with 2000 atoms Performance: 0.863 ns/day, 27.823 hours/ns, 9.984 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.655 | 99.655 | 99.655 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076851 | 0.076851 | 0.076851 | 0.0 | 0.08 Output | 0.00014975 | 0.00014975 | 0.00014975 | 0.0 | 0.00 Modify | 0.374 | 0.374 | 0.374 | 0.0 | 0.37 Other | | 0.05764 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116156.0 ave 116156 max 116156 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116156 Ave neighs/atom = 58.078000 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 = 293.656605133599, Press = 15.0045705404742 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.8912 -8042.8912 -8118.2416 -8118.2416 291.6138 291.6138 24053.593 24053.593 2662.7221 2662.7221 14000 -8046.6473 -8046.6473 -8120.4415 -8120.4415 285.59091 285.59091 24105.366 24105.366 -1683.6177 -1683.6177 Loop time of 102.537 on 1 procs for 1000 steps with 2000 atoms Performance: 0.843 ns/day, 28.483 hours/ns, 9.753 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 102.01 | 102.01 | 102.01 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.078369 | 0.078369 | 0.078369 | 0.0 | 0.08 Output | 0.00015733 | 0.00015733 | 0.00015733 | 0.0 | 0.00 Modify | 0.38572 | 0.38572 | 0.38572 | 0.0 | 0.38 Other | | 0.05833 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116218.0 ave 116218 max 116218 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116218 Ave neighs/atom = 58.109000 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 = 293.346129658986, Press = 16.5853842765046 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8046.6473 -8046.6473 -8120.4415 -8120.4415 285.59091 285.59091 24105.366 24105.366 -1683.6177 -1683.6177 15000 -8043.5037 -8043.5037 -8120.9037 -8120.9037 299.54604 299.54604 24070.685 24070.685 1177.9457 1177.9457 Loop time of 101.769 on 1 procs for 1000 steps with 2000 atoms Performance: 0.849 ns/day, 28.269 hours/ns, 9.826 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 101.25 | 101.25 | 101.25 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077476 | 0.077476 | 0.077476 | 0.0 | 0.08 Output | 0.00042181 | 0.00042181 | 0.00042181 | 0.0 | 0.00 Modify | 0.38231 | 0.38231 | 0.38231 | 0.0 | 0.38 Other | | 0.05807 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116148.0 ave 116148 max 116148 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116148 Ave neighs/atom = 58.074000 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 = 293.42198196775, Press = 9.0658262845554 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.5037 -8043.5037 -8120.9037 -8120.9037 299.54604 299.54604 24070.685 24070.685 1177.9457 1177.9457 16000 -8044.6519 -8044.6519 -8120.3392 -8120.3392 292.91751 292.91751 24106.624 24106.624 -1676.2349 -1676.2349 Loop time of 100.025 on 1 procs for 1000 steps with 2000 atoms Performance: 0.864 ns/day, 27.785 hours/ns, 9.998 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.519 | 99.519 | 99.519 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076901 | 0.076901 | 0.076901 | 0.0 | 0.08 Output | 0.00014895 | 0.00014895 | 0.00014895 | 0.0 | 0.00 Modify | 0.3715 | 0.3715 | 0.3715 | 0.0 | 0.37 Other | | 0.05738 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.657647361926, Press = 19.638638484518 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.6519 -8044.6519 -8120.3392 -8120.3392 292.91751 292.91751 24106.624 24106.624 -1676.2349 -1676.2349 17000 -8041.7654 -8041.7654 -8120.548 -8120.548 304.89675 304.89675 24085.684 24085.684 79.449612 79.449612 Loop time of 101.273 on 1 procs for 1000 steps with 2000 atoms Performance: 0.853 ns/day, 28.131 hours/ns, 9.874 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.75 | 100.75 | 100.75 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077614 | 0.077614 | 0.077614 | 0.0 | 0.08 Output | 0.00019216 | 0.00019216 | 0.00019216 | 0.0 | 0.00 Modify | 0.38282 | 0.38282 | 0.38282 | 0.0 | 0.38 Other | | 0.05855 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116190.0 ave 116190 max 116190 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116190 Ave neighs/atom = 58.095000 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 = 293.644813763013, Press = 1.97864113651541 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8041.7654 -8041.7654 -8120.548 -8120.548 304.89675 304.89675 24085.684 24085.684 79.449612 79.449612 18000 -8045.5018 -8045.5018 -8119.4593 -8119.4593 286.22323 286.22323 24077.441 24077.441 701.83439 701.83439 Loop time of 99.0265 on 1 procs for 1000 steps with 2000 atoms Performance: 0.872 ns/day, 27.507 hours/ns, 10.098 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.523 | 98.523 | 98.523 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076941 | 0.076941 | 0.076941 | 0.0 | 0.08 Output | 0.00015563 | 0.00015563 | 0.00015563 | 0.0 | 0.00 Modify | 0.36905 | 0.36905 | 0.36905 | 0.0 | 0.37 Other | | 0.05773 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116148.0 ave 116148 max 116148 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116148 Ave neighs/atom = 58.074000 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 = 293.681696487386, Press = 14.2356193037175 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8045.5018 -8045.5018 -8119.4593 -8119.4593 286.22323 286.22323 24077.441 24077.441 701.83439 701.83439 19000 -8042.5153 -8042.5153 -8118.2513 -8118.2513 293.10647 293.10647 24094.293 24094.293 -306.90929 -306.90929 Loop time of 99.4402 on 1 procs for 1000 steps with 2000 atoms Performance: 0.869 ns/day, 27.622 hours/ns, 10.056 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.94 | 98.94 | 98.94 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076149 | 0.076149 | 0.076149 | 0.0 | 0.08 Output | 0.00015963 | 0.00015963 | 0.00015963 | 0.0 | 0.00 Modify | 0.36687 | 0.36687 | 0.36687 | 0.0 | 0.37 Other | | 0.05683 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.778828699182, Press = 6.66175837797857 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.5153 -8042.5153 -8118.2513 -8118.2513 293.10647 293.10647 24094.293 24094.293 -306.90929 -306.90929 20000 -8042.9316 -8042.9316 -8116.2875 -8116.2875 283.8949 283.8949 24079.06 24079.06 980.48027 980.48027 Loop time of 99.7188 on 1 procs for 1000 steps with 2000 atoms Performance: 0.866 ns/day, 27.700 hours/ns, 10.028 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.214 | 99.214 | 99.214 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076493 | 0.076493 | 0.076493 | 0.0 | 0.08 Output | 0.00024111 | 0.00024111 | 0.00024111 | 0.0 | 0.00 Modify | 0.37039 | 0.37039 | 0.37039 | 0.0 | 0.37 Other | | 0.05734 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116186.0 ave 116186 max 116186 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116186 Ave neighs/atom = 58.093000 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 = 293.684022884797, Press = 11.4365255629828 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.9316 -8042.9316 -8116.2875 -8116.2875 283.8949 283.8949 24079.06 24079.06 980.48027 980.48027 21000 -8044.5104 -8044.5104 -8119.4558 -8119.4558 290.04664 290.04664 24105.826 24105.826 -1482.23 -1482.23 Loop time of 100.359 on 1 procs for 1000 steps with 2000 atoms Performance: 0.861 ns/day, 27.877 hours/ns, 9.964 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.851 | 99.851 | 99.851 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076544 | 0.076544 | 0.076544 | 0.0 | 0.08 Output | 0.00015087 | 0.00015087 | 0.00015087 | 0.0 | 0.00 Modify | 0.37278 | 0.37278 | 0.37278 | 0.0 | 0.37 Other | | 0.05765 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2947.00 ave 2947 max 2947 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116196.0 ave 116196 max 116196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116196 Ave neighs/atom = 58.098000 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 = 293.679106891785, Press = 3.8202194606352 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.5104 -8044.5104 -8119.4558 -8119.4558 290.04664 290.04664 24105.826 24105.826 -1482.23 -1482.23 22000 -8043.2977 -8043.2977 -8119.4932 -8119.4932 294.8846 294.8846 24047.708 24047.708 3096.0654 3096.0654 Loop time of 99.2575 on 1 procs for 1000 steps with 2000 atoms Performance: 0.870 ns/day, 27.572 hours/ns, 10.075 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.757 | 98.757 | 98.757 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075553 | 0.075553 | 0.075553 | 0.0 | 0.08 Output | 0.00015823 | 0.00015823 | 0.00015823 | 0.0 | 0.00 Modify | 0.36752 | 0.36752 | 0.36752 | 0.0 | 0.37 Other | | 0.05701 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116160.0 ave 116160 max 116160 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116160 Ave neighs/atom = 58.080000 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 = 293.478883206876, Press = 13.0674855842901 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.2977 -8043.2977 -8119.4932 -8119.4932 294.8846 294.8846 24047.708 24047.708 3096.0654 3096.0654 23000 -8047.1283 -8047.1283 -8119.7358 -8119.7358 280.99843 280.99843 24116.405 24116.405 -2216.9917 -2216.9917 Loop time of 100.454 on 1 procs for 1000 steps with 2000 atoms Performance: 0.860 ns/day, 27.904 hours/ns, 9.955 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.944 | 99.944 | 99.944 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077082 | 0.077082 | 0.077082 | 0.0 | 0.08 Output | 0.00015156 | 0.00015156 | 0.00015156 | 0.0 | 0.00 Modify | 0.37431 | 0.37431 | 0.37431 | 0.0 | 0.37 Other | | 0.05819 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116214.0 ave 116214 max 116214 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116214 Ave neighs/atom = 58.107000 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 = 293.435303206205, Press = 5.26483372153521 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8047.1283 -8047.1283 -8119.7358 -8119.7358 280.99843 280.99843 24116.405 24116.405 -2216.9917 -2216.9917 24000 -8041.8769 -8041.8769 -8119.3643 -8119.3643 299.8841 299.8841 24058.303 24058.303 2219.3084 2219.3084 Loop time of 99.296 on 1 procs for 1000 steps with 2000 atoms Performance: 0.870 ns/day, 27.582 hours/ns, 10.071 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.796 | 98.796 | 98.796 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.0762 | 0.0762 | 0.0762 | 0.0 | 0.08 Output | 0.00015612 | 0.00015612 | 0.00015612 | 0.0 | 0.00 Modify | 0.367 | 0.367 | 0.367 | 0.0 | 0.37 Other | | 0.05698 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116154.0 ave 116154 max 116154 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116154 Ave neighs/atom = 58.077000 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 = 293.38468050546, Press = 8.77340088692715 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8041.8769 -8041.8769 -8119.3643 -8119.3643 299.8841 299.8841 24058.303 24058.303 2219.3084 2219.3084 25000 -8044.5612 -8044.5612 -8119.9141 -8119.9141 291.62366 291.62366 24116.706 24116.706 -2368.3816 -2368.3816 Loop time of 98.7783 on 1 procs for 1000 steps with 2000 atoms Performance: 0.875 ns/day, 27.438 hours/ns, 10.124 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.281 | 98.281 | 98.281 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075478 | 0.075478 | 0.075478 | 0.0 | 0.08 Output | 0.00016849 | 0.00016849 | 0.00016849 | 0.0 | 0.00 Modify | 0.36514 | 0.36514 | 0.36514 | 0.0 | 0.37 Other | | 0.05677 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116222.0 ave 116222 max 116222 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116222 Ave neighs/atom = 58.111000 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 = 293.402622095079, Press = 6.18085490875236 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.5612 -8044.5612 -8119.9141 -8119.9141 291.62366 291.62366 24116.706 24116.706 -2368.3816 -2368.3816 26000 -8043.3127 -8043.3127 -8118.7649 -8118.7649 292.00784 292.00784 24060.961 24060.961 2094.9409 2094.9409 Loop time of 99.9956 on 1 procs for 1000 steps with 2000 atoms Performance: 0.864 ns/day, 27.777 hours/ns, 10.000 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.489 | 99.489 | 99.489 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076301 | 0.076301 | 0.076301 | 0.0 | 0.08 Output | 0.00020788 | 0.00020788 | 0.00020788 | 0.0 | 0.00 Modify | 0.37267 | 0.37267 | 0.37267 | 0.0 | 0.37 Other | | 0.05748 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116172.0 ave 116172 max 116172 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116172 Ave neighs/atom = 58.086000 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 = 293.369102528239, Press = 6.23781570284824 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.3127 -8043.3127 -8118.7649 -8118.7649 292.00784 292.00784 24060.961 24060.961 2094.9409 2094.9409 27000 -8042.6983 -8042.6983 -8119.8558 -8119.8558 298.60739 298.60739 24111.563 24111.563 -1879.8552 -1879.8552 Loop time of 98.4761 on 1 procs for 1000 steps with 2000 atoms Performance: 0.877 ns/day, 27.354 hours/ns, 10.155 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 97.979 | 97.979 | 97.979 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075695 | 0.075695 | 0.075695 | 0.0 | 0.08 Output | 0.00015406 | 0.00015406 | 0.00015406 | 0.0 | 0.00 Modify | 0.36459 | 0.36459 | 0.36459 | 0.0 | 0.37 Other | | 0.05706 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116202.0 ave 116202 max 116202 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116202 Ave neighs/atom = 58.101000 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 = 293.488496378603, Press = 6.34011305112972 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.6983 -8042.6983 -8119.8558 -8119.8558 298.60739 298.60739 24111.563 24111.563 -1879.8552 -1879.8552 28000 -8046.9912 -8046.9912 -8120.6361 -8120.6361 285.01351 285.01351 24062.455 24062.455 1617.6369 1617.6369 Loop time of 98.9075 on 1 procs for 1000 steps with 2000 atoms Performance: 0.874 ns/day, 27.474 hours/ns, 10.110 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.41 | 98.41 | 98.41 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075636 | 0.075636 | 0.075636 | 0.0 | 0.08 Output | 0.00015844 | 0.00015844 | 0.00015844 | 0.0 | 0.00 Modify | 0.36452 | 0.36452 | 0.36452 | 0.0 | 0.37 Other | | 0.05681 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116160.0 ave 116160 max 116160 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116160 Ave neighs/atom = 58.080000 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 = 293.445508345927, Press = 5.52878169541371 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8046.9912 -8046.9912 -8120.6361 -8120.6361 285.01351 285.01351 24062.455 24062.455 1617.6369 1617.6369 29000 -8043.4291 -8043.4291 -8120.2385 -8120.2385 297.2601 297.2601 24113.014 24113.014 -2100.8185 -2100.8185 Loop time of 101.092 on 1 procs for 1000 steps with 2000 atoms Performance: 0.855 ns/day, 28.081 hours/ns, 9.892 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.58 | 100.58 | 100.58 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07717 | 0.07717 | 0.07717 | 0.0 | 0.08 Output | 0.00019521 | 0.00019521 | 0.00019521 | 0.0 | 0.00 Modify | 0.37795 | 0.37795 | 0.37795 | 0.0 | 0.37 Other | | 0.05803 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116216.0 ave 116216 max 116216 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116216 Ave neighs/atom = 58.108000 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 = 293.31768117155, Press = 5.93823821760815 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.4291 -8043.4291 -8120.2385 -8120.2385 297.2601 297.2601 24113.014 24113.014 -2100.8185 -2100.8185 30000 -8044.7415 -8044.7415 -8120.1047 -8120.1047 291.66341 291.66341 24042.069 24042.069 3330.51 3330.51 Loop time of 100.198 on 1 procs for 1000 steps with 2000 atoms Performance: 0.862 ns/day, 27.833 hours/ns, 9.980 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.689 | 99.689 | 99.689 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076523 | 0.076523 | 0.076523 | 0.0 | 0.08 Output | 0.00015484 | 0.00015484 | 0.00015484 | 0.0 | 0.00 Modify | 0.37404 | 0.37404 | 0.37404 | 0.0 | 0.37 Other | | 0.0584 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116184.0 ave 116184 max 116184 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116184 Ave neighs/atom = 58.092000 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 = 293.313563604528, Press = 3.91965091573552 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.7415 -8044.7415 -8120.1047 -8120.1047 291.66341 291.66341 24042.069 24042.069 3330.51 3330.51 31000 -8044.9287 -8044.9287 -8120.3894 -8120.3894 292.04093 292.04093 24118.952 24118.952 -2622.5928 -2622.5928 Loop time of 100.714 on 1 procs for 1000 steps with 2000 atoms Performance: 0.858 ns/day, 27.976 hours/ns, 9.929 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.2 | 100.2 | 100.2 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.077918 | 0.077918 | 0.077918 | 0.0 | 0.08 Output | 0.00020105 | 0.00020105 | 0.00020105 | 0.0 | 0.00 Modify | 0.37649 | 0.37649 | 0.37649 | 0.0 | 0.37 Other | | 0.05848 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2951.00 ave 2951 max 2951 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116214.0 ave 116214 max 116214 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116214 Ave neighs/atom = 58.107000 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 = 293.179902475599, Press = 8.20213498948126 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.9287 -8044.9287 -8120.3894 -8120.3894 292.04093 292.04093 24118.952 24118.952 -2622.5928 -2622.5928 32000 -8046.2098 -8046.2098 -8122.1632 -8122.1632 293.94727 293.94727 24075.832 24075.832 571.35426 571.35426 Loop time of 101.285 on 1 procs for 1000 steps with 2000 atoms Performance: 0.853 ns/day, 28.135 hours/ns, 9.873 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.77 | 100.77 | 100.77 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07773 | 0.07773 | 0.07773 | 0.0 | 0.08 Output | 0.00020777 | 0.00020777 | 0.00020777 | 0.0 | 0.00 Modify | 0.37874 | 0.37874 | 0.37874 | 0.0 | 0.37 Other | | 0.0581 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116166.0 ave 116166 max 116166 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116166 Ave neighs/atom = 58.083000 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 = 293.164008423295, Press = 3.36532104230281 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8046.2098 -8046.2098 -8122.1632 -8122.1632 293.94727 293.94727 24075.832 24075.832 571.35426 571.35426 33000 -8046.5382 -8046.5382 -8120.2584 -8120.2584 285.3045 285.3045 24082.26 24082.26 190.25659 190.25659 Loop time of 98.4561 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.349 hours/ns, 10.157 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 97.959 | 97.959 | 97.959 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075413 | 0.075413 | 0.075413 | 0.0 | 0.08 Output | 0.00015459 | 0.00015459 | 0.00015459 | 0.0 | 0.00 Modify | 0.3647 | 0.3647 | 0.3647 | 0.0 | 0.37 Other | | 0.05667 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116184.0 ave 116184 max 116184 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116184 Ave neighs/atom = 58.092000 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 = 293.120550734032, Press = 6.17005168041756 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8046.5382 -8046.5382 -8120.2584 -8120.2584 285.3045 285.3045 24082.26 24082.26 190.25659 190.25659 34000 -8038.7905 -8038.7905 -8117.3508 -8117.3508 304.03613 304.03613 24104.467 24104.467 -1082.275 -1082.275 Loop time of 99.9052 on 1 procs for 1000 steps with 2000 atoms Performance: 0.865 ns/day, 27.751 hours/ns, 10.009 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.4 | 99.4 | 99.4 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076938 | 0.076938 | 0.076938 | 0.0 | 0.08 Output | 0.00020074 | 0.00020074 | 0.00020074 | 0.0 | 0.00 Modify | 0.37067 | 0.37067 | 0.37067 | 0.0 | 0.37 Other | | 0.05733 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116156.0 ave 116156 max 116156 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116156 Ave neighs/atom = 58.078000 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 = 293.171407965879, Press = 3.16254856941612 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8038.7905 -8038.7905 -8117.3508 -8117.3508 304.03613 304.03613 24104.467 24104.467 -1082.275 -1082.275 35000 -8045.1723 -8045.1723 -8119.8771 -8119.8771 289.11524 289.11524 24061.897 24061.897 1795.235 1795.235 Loop time of 99.2699 on 1 procs for 1000 steps with 2000 atoms Performance: 0.870 ns/day, 27.575 hours/ns, 10.074 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.767 | 98.767 | 98.767 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07693 | 0.07693 | 0.07693 | 0.0 | 0.08 Output | 0.0001921 | 0.0001921 | 0.0001921 | 0.0 | 0.00 Modify | 0.36807 | 0.36807 | 0.36807 | 0.0 | 0.37 Other | | 0.05725 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116212.0 ave 116212 max 116212 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116212 Ave neighs/atom = 58.106000 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 = 293.216985628407, Press = 6.30790798311358 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8045.1723 -8045.1723 -8119.8771 -8119.8771 289.11524 289.11524 24061.897 24061.897 1795.235 1795.235 36000 -8040.4065 -8040.4065 -8117.9896 -8117.9896 300.25461 300.25461 24139.55 24139.55 -4006.7104 -4006.7104 Loop time of 100.464 on 1 procs for 1000 steps with 2000 atoms Performance: 0.860 ns/day, 27.907 hours/ns, 9.954 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.953 | 99.953 | 99.953 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07728 | 0.07728 | 0.07728 | 0.0 | 0.08 Output | 0.00015489 | 0.00015489 | 0.00015489 | 0.0 | 0.00 Modify | 0.37484 | 0.37484 | 0.37484 | 0.0 | 0.37 Other | | 0.05803 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116182.0 ave 116182 max 116182 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116182 Ave neighs/atom = 58.091000 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 = 293.301963650433, Press = 2.15602343902256 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8040.4065 -8040.4065 -8117.9896 -8117.9896 300.25461 300.25461 24139.55 24139.55 -4006.7104 -4006.7104 37000 -8042.6606 -8042.6606 -8118.9573 -8118.9573 295.27593 295.27593 24049.117 24049.117 3083.3803 3083.3803 Loop time of 99.6044 on 1 procs for 1000 steps with 2000 atoms Performance: 0.867 ns/day, 27.668 hours/ns, 10.040 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.099 | 99.099 | 99.099 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07614 | 0.07614 | 0.07614 | 0.0 | 0.08 Output | 0.00015199 | 0.00015199 | 0.00015199 | 0.0 | 0.00 Modify | 0.3715 | 0.3715 | 0.3715 | 0.0 | 0.37 Other | | 0.05765 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116150.0 ave 116150 max 116150 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116150 Ave neighs/atom = 58.075000 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 = 293.279916959946, Press = 5.57504357226924 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.6606 -8042.6606 -8118.9573 -8118.9573 295.27593 295.27593 24049.117 24049.117 3083.3803 3083.3803 38000 -8043.7725 -8043.7725 -8118.4529 -8118.4529 289.02084 289.02084 24101.058 24101.058 -1005.9209 -1005.9209 Loop time of 98.9381 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.483 hours/ns, 10.107 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 | 98.438 | 98.438 | 98.438 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07577 | 0.07577 | 0.07577 | 0.0 | 0.08 Output | 0.00018936 | 0.00018936 | 0.00018936 | 0.0 | 0.00 Modify | 0.36667 | 0.36667 | 0.36667 | 0.0 | 0.37 Other | | 0.05749 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116188.0 ave 116188 max 116188 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116188 Ave neighs/atom = 58.094000 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 = 293.236597438067, Press = 4.14902064061629 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.7725 -8043.7725 -8118.4529 -8118.4529 289.02084 289.02084 24101.058 24101.058 -1005.9209 -1005.9209 39000 -8045.6102 -8045.6102 -8119.7634 -8119.7634 286.98075 286.98075 24066.553 24066.553 1396.1385 1396.1385 Loop time of 98.9744 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.493 hours/ns, 10.104 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 | 98.474 | 98.474 | 98.474 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076151 | 0.076151 | 0.076151 | 0.0 | 0.08 Output | 0.00019221 | 0.00019221 | 0.00019221 | 0.0 | 0.00 Modify | 0.3666 | 0.3666 | 0.3666 | 0.0 | 0.37 Other | | 0.05714 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116170.0 ave 116170 max 116170 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116170 Ave neighs/atom = 58.085000 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 = 293.162538581493, Press = 3.92526453265131 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8045.6102 -8045.6102 -8119.7634 -8119.7634 286.98075 286.98075 24066.553 24066.553 1396.1385 1396.1385 40000 -8042.7001 -8042.7001 -8118.5725 -8118.5725 293.63419 293.63419 24101.52 24101.52 -1052.715 -1052.715 Loop time of 98.3937 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.332 hours/ns, 10.163 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 | 97.893 | 97.893 | 97.893 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076766 | 0.076766 | 0.076766 | 0.0 | 0.08 Output | 0.00015276 | 0.00015276 | 0.00015276 | 0.0 | 0.00 Modify | 0.36636 | 0.36636 | 0.36636 | 0.0 | 0.37 Other | | 0.05739 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116176.0 ave 116176 max 116176 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116176 Ave neighs/atom = 58.088000 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 = 293.100177513558, Press = 4.37143110798644 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.7001 -8042.7001 -8118.5725 -8118.5725 293.63419 293.63419 24101.52 24101.52 -1052.715 -1052.715 41000 -8044.8392 -8044.8392 -8120.8506 -8120.8506 294.17203 294.17203 24067.704 24067.704 1317.2767 1317.2767 Loop time of 98.6003 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.389 hours/ns, 10.142 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.101 | 98.101 | 98.101 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076028 | 0.076028 | 0.076028 | 0.0 | 0.08 Output | 0.0003717 | 0.0003717 | 0.0003717 | 0.0 | 0.00 Modify | 0.36607 | 0.36607 | 0.36607 | 0.0 | 0.37 Other | | 0.05724 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116182.0 ave 116182 max 116182 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116182 Ave neighs/atom = 58.091000 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 = 293.077286673587, Press = 2.67081186387078 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.8392 -8044.8392 -8120.8506 -8120.8506 294.17203 294.17203 24067.704 24067.704 1317.2767 1317.2767 42000 -8044.126 -8044.126 -8119.3184 -8119.3184 291.00223 291.00223 24101.724 24101.724 -1157.2745 -1157.2745 Loop time of 98.6478 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.402 hours/ns, 10.137 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.147 | 98.147 | 98.147 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076268 | 0.076268 | 0.076268 | 0.0 | 0.08 Output | 0.00015468 | 0.00015468 | 0.00015468 | 0.0 | 0.00 Modify | 0.36732 | 0.36732 | 0.36732 | 0.0 | 0.37 Other | | 0.05714 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116176.0 ave 116176 max 116176 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116176 Ave neighs/atom = 58.088000 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 = 293.091112151402, Press = 5.86283292975407 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.126 -8044.126 -8119.3184 -8119.3184 291.00223 291.00223 24101.724 24101.724 -1157.2745 -1157.2745 43000 -8043.2611 -8043.2611 -8117.5436 -8117.5436 287.48121 287.48121 24078.371 24078.371 822.41506 822.41506 Loop time of 97.9795 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.217 hours/ns, 10.206 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 | 97.485 | 97.485 | 97.485 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075163 | 0.075163 | 0.075163 | 0.0 | 0.08 Output | 0.00015306 | 0.00015306 | 0.00015306 | 0.0 | 0.00 Modify | 0.36233 | 0.36233 | 0.36233 | 0.0 | 0.37 Other | | 0.057 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116166.0 ave 116166 max 116166 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116166 Ave neighs/atom = 58.083000 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 = 293.075666743285, Press = 2.07356784364441 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8043.2611 -8043.2611 -8117.5436 -8117.5436 287.48121 287.48121 24078.371 24078.371 822.41506 822.41506 44000 -8042.8805 -8042.8805 -8120.4023 -8120.4023 300.01721 300.01721 24087.043 24087.043 -48.083282 -48.083282 Loop time of 97.951 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.209 hours/ns, 10.209 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 | 97.457 | 97.457 | 97.457 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075293 | 0.075293 | 0.075293 | 0.0 | 0.08 Output | 0.00014998 | 0.00014998 | 0.00014998 | 0.0 | 0.00 Modify | 0.36235 | 0.36235 | 0.36235 | 0.0 | 0.37 Other | | 0.05659 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116196.0 ave 116196 max 116196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116196 Ave neighs/atom = 58.098000 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 = 293.088420766252, Press = 4.87663060310636 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8042.8805 -8042.8805 -8120.4023 -8120.4023 300.01721 300.01721 24087.043 24087.043 -48.083282 -48.083282 45000 -8040.729 -8040.729 -8118.7401 -8118.7401 301.9108 301.9108 24097.899 24097.899 -647.68218 -647.68218 Loop time of 98.6364 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.399 hours/ns, 10.138 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 | 98.138 | 98.138 | 98.138 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075495 | 0.075495 | 0.075495 | 0.0 | 0.08 Output | 0.00015351 | 0.00015351 | 0.00015351 | 0.0 | 0.00 Modify | 0.36591 | 0.36591 | 0.36591 | 0.0 | 0.37 Other | | 0.05679 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116156.0 ave 116156 max 116156 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116156 Ave neighs/atom = 58.078000 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 = 293.070402656523, Press = 2.90318291167087 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8040.729 -8040.729 -8118.7401 -8118.7401 301.9108 301.9108 24097.899 24097.899 -647.68218 -647.68218 46000 -8044.4393 -8044.4393 -8119.0162 -8119.0162 288.62057 288.62057 24078.865 24078.865 516.7809 516.7809 Loop time of 97.1391 on 1 procs for 1000 steps with 2000 atoms Performance: 0.889 ns/day, 26.983 hours/ns, 10.295 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 | 96.65 | 96.65 | 96.65 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074651 | 0.074651 | 0.074651 | 0.0 | 0.08 Output | 0.00015368 | 0.00015368 | 0.00015368 | 0.0 | 0.00 Modify | 0.35798 | 0.35798 | 0.35798 | 0.0 | 0.37 Other | | 0.05656 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116184.0 ave 116184 max 116184 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116184 Ave neighs/atom = 58.092000 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 = 293.108230316291, Press = 3.56557474538979 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8044.4393 -8044.4393 -8119.0162 -8119.0162 288.62057 288.62057 24078.865 24078.865 516.7809 516.7809 47000 -8041.2642 -8041.2642 -8119.4514 -8119.4514 302.59234 302.59234 24096.356 24096.356 -729.09358 -729.09358 Loop time of 97.5659 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.102 hours/ns, 10.249 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 | 97.072 | 97.072 | 97.072 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075767 | 0.075767 | 0.075767 | 0.0 | 0.08 Output | 0.00024411 | 0.00024411 | 0.00024411 | 0.0 | 0.00 Modify | 0.3605 | 0.3605 | 0.3605 | 0.0 | 0.37 Other | | 0.05743 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116210.0 ave 116210 max 116210 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116210 Ave neighs/atom = 58.105000 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 = 293.157105618417, Press = 3.051060193093 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 -8041.2642 -8041.2642 -8119.4514 -8119.4514 302.59234 302.59234 24096.356 24096.356 -729.09358 -729.09358 48000 -8045.7369 -8045.7369 -8120.073 -8120.073 287.68835 287.68835 24074.565 24074.565 703.3195 703.3195 Loop time of 98.6792 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.411 hours/ns, 10.134 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 | 98.179 | 98.179 | 98.179 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075937 | 0.075937 | 0.075937 | 0.0 | 0.08 Output | 0.00015301 | 0.00015301 | 0.00015301 | 0.0 | 0.00 Modify | 0.36717 | 0.36717 | 0.36717 | 0.0 | 0.37 Other | | 0.05727 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116178.0 ave 116178 max 116178 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116178 Ave neighs/atom = 58.089000 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 = 293.172940324186, Press = 2.91370830592479 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 48000 -8045.7369 -8045.7369 -8120.073 -8120.073 287.68835 287.68835 24074.565 24074.565 703.3195 703.3195 49000 -8039.9068 -8039.9068 -8118.5946 -8118.5946 304.53 304.53 24104.568 24104.568 -1218.6492 -1218.6492 Loop time of 99.1505 on 1 procs for 1000 steps with 2000 atoms Performance: 0.871 ns/day, 27.542 hours/ns, 10.086 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.647 | 98.647 | 98.647 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.0766 | 0.0766 | 0.0766 | 0.0 | 0.08 Output | 0.00019471 | 0.00019471 | 0.00019471 | 0.0 | 0.00 Modify | 0.3691 | 0.3691 | 0.3691 | 0.0 | 0.37 Other | | 0.05744 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116240.0 ave 116240 max 116240 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116240 Ave neighs/atom = 58.120000 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 = 293.197622241709, Press = 3.05439034588829 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 49000 -8039.9068 -8039.9068 -8118.5946 -8118.5946 304.53 304.53 24104.568 24104.568 -1218.6492 -1218.6492 50000 -8044.1402 -8044.1402 -8118.4096 -8118.4096 287.43049 287.43049 24061.667 24061.667 1919.6863 1919.6863 Loop time of 97.5594 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.100 hours/ns, 10.250 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 97.066 | 97.066 | 97.066 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07597 | 0.07597 | 0.07597 | 0.0 | 0.08 Output | 0.00019857 | 0.00019857 | 0.00019857 | 0.0 | 0.00 Modify | 0.36047 | 0.36047 | 0.36047 | 0.0 | 0.37 Other | | 0.05665 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.253665810302, Press = 2.92134530458789 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 50000 -8044.1402 -8044.1402 -8118.4096 -8118.4096 287.43049 287.43049 24061.667 24061.667 1919.6863 1919.6863 51000 -8044.5322 -8044.5322 -8119.1221 -8119.1221 288.67055 288.67055 24114.358 24114.358 -2251.1752 -2251.1752 Loop time of 98.0784 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.244 hours/ns, 10.196 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 | 97.583 | 97.583 | 97.583 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075627 | 0.075627 | 0.075627 | 0.0 | 0.08 Output | 0.00015951 | 0.00015951 | 0.00015951 | 0.0 | 0.00 Modify | 0.36212 | 0.36212 | 0.36212 | 0.0 | 0.37 Other | | 0.05719 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116218.0 ave 116218 max 116218 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116218 Ave neighs/atom = 58.109000 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 = 293.22707897074, Press = 2.88006428819786 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 51000 -8044.5322 -8044.5322 -8119.1221 -8119.1221 288.67055 288.67055 24114.358 24114.358 -2251.1752 -2251.1752 52000 -8042.2461 -8042.2461 -8119.064 -8119.064 297.29303 297.29303 24044.611 24044.611 3266.2379 3266.2379 Loop time of 97.9551 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.210 hours/ns, 10.209 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 | 97.461 | 97.461 | 97.461 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075853 | 0.075853 | 0.075853 | 0.0 | 0.08 Output | 0.00014528 | 0.00014528 | 0.00014528 | 0.0 | 0.00 Modify | 0.36145 | 0.36145 | 0.36145 | 0.0 | 0.37 Other | | 0.05684 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116160.0 ave 116160 max 116160 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116160 Ave neighs/atom = 58.080000 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 = 293.25853658653, Press = 2.18592526882737 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 52000 -8042.2461 -8042.2461 -8119.064 -8119.064 297.29303 297.29303 24044.611 24044.611 3266.2379 3266.2379 53000 -8043.5956 -8043.5956 -8120.0827 -8120.0827 296.0129 296.0129 24122.208 24122.208 -2781.5377 -2781.5377 Loop time of 98.8214 on 1 procs for 1000 steps with 2000 atoms Performance: 0.874 ns/day, 27.450 hours/ns, 10.119 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 | 98.321 | 98.321 | 98.321 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076411 | 0.076411 | 0.076411 | 0.0 | 0.08 Output | 0.00024232 | 0.00024232 | 0.00024232 | 0.0 | 0.00 Modify | 0.36665 | 0.36665 | 0.36665 | 0.0 | 0.37 Other | | 0.05754 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116214.0 ave 116214 max 116214 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116214 Ave neighs/atom = 58.107000 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 = 293.260769210137, Press = 3.82309476404059 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 53000 -8043.5956 -8043.5956 -8120.0827 -8120.0827 296.0129 296.0129 24122.208 24122.208 -2781.5377 -2781.5377 54000 -8041.825 -8041.825 -8118.7235 -8118.7235 297.60501 297.60501 24074.2 24074.2 1043.5356 1043.5356 Loop time of 98.1493 on 1 procs for 1000 steps with 2000 atoms Performance: 0.880 ns/day, 27.264 hours/ns, 10.189 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 | 97.655 | 97.655 | 97.655 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075497 | 0.075497 | 0.075497 | 0.0 | 0.08 Output | 0.00015453 | 0.00015453 | 0.00015453 | 0.0 | 0.00 Modify | 0.36182 | 0.36182 | 0.36182 | 0.0 | 0.37 Other | | 0.05708 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116164.0 ave 116164 max 116164 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116164 Ave neighs/atom = 58.082000 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 = 293.31974621986, Press = 2.04498254155886 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 54000 -8041.825 -8041.825 -8118.7235 -8118.7235 297.60501 297.60501 24074.2 24074.2 1043.5356 1043.5356 55000 -8044.1353 -8044.1353 -8119.1271 -8119.1271 290.2261 290.2261 24091.581 24091.581 -354.59064 -354.59064 Loop time of 98.0668 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.241 hours/ns, 10.197 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 | 97.571 | 97.571 | 97.571 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075482 | 0.075482 | 0.075482 | 0.0 | 0.08 Output | 0.00014576 | 0.00014576 | 0.00014576 | 0.0 | 0.00 Modify | 0.36333 | 0.36333 | 0.36333 | 0.0 | 0.37 Other | | 0.05667 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116186.0 ave 116186 max 116186 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116186 Ave neighs/atom = 58.093000 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 = 293.328273639684, Press = 3.13015412069037 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 55000 -8044.1353 -8044.1353 -8119.1271 -8119.1271 290.2261 290.2261 24091.581 24091.581 -354.59064 -354.59064 56000 -8047.3664 -8047.3664 -8119.7415 -8119.7415 280.09908 280.09908 24080.069 24080.069 318.0748 318.0748 Loop time of 98.5874 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.385 hours/ns, 10.143 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 | 98.089 | 98.089 | 98.089 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075535 | 0.075535 | 0.075535 | 0.0 | 0.08 Output | 0.00015379 | 0.00015379 | 0.00015379 | 0.0 | 0.00 Modify | 0.36626 | 0.36626 | 0.36626 | 0.0 | 0.37 Other | | 0.05698 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116182.0 ave 116182 max 116182 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116182 Ave neighs/atom = 58.091000 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 = 293.327080219467, Press = 2.12520613519245 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 56000 -8047.3664 -8047.3664 -8119.7415 -8119.7415 280.09908 280.09908 24080.069 24080.069 318.0748 318.0748 57000 -8043.6255 -8043.6255 -8118.3535 -8118.3535 289.20534 289.20534 24083.033 24083.033 378.92207 378.92207 Loop time of 98.8694 on 1 procs for 1000 steps with 2000 atoms Performance: 0.874 ns/day, 27.464 hours/ns, 10.114 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 | 98.369 | 98.369 | 98.369 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076144 | 0.076144 | 0.076144 | 0.0 | 0.08 Output | 0.00015563 | 0.00015563 | 0.00015563 | 0.0 | 0.00 Modify | 0.36656 | 0.36656 | 0.36656 | 0.0 | 0.37 Other | | 0.05757 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116160.0 ave 116160 max 116160 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116160 Ave neighs/atom = 58.080000 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 = 293.275808148623, Press = 3.49654129779182 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 57000 -8043.6255 -8043.6255 -8118.3535 -8118.3535 289.20534 289.20534 24083.033 24083.033 378.92207 378.92207 58000 -8047.1089 -8047.1089 -8120.6347 -8120.6347 284.55227 284.55227 24098.418 24098.418 -1206.9224 -1206.9224 Loop time of 99.3293 on 1 procs for 1000 steps with 2000 atoms Performance: 0.870 ns/day, 27.591 hours/ns, 10.068 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 | 98.824 | 98.824 | 98.824 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07682 | 0.07682 | 0.07682 | 0.0 | 0.08 Output | 0.00015883 | 0.00015883 | 0.00015883 | 0.0 | 0.00 Modify | 0.37119 | 0.37119 | 0.37119 | 0.0 | 0.37 Other | | 0.05721 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116200.0 ave 116200 max 116200 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116200 Ave neighs/atom = 58.100000 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 = 293.262954875767, Press = 0.731124532186346 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 58000 -8047.1089 -8047.1089 -8120.6347 -8120.6347 284.55227 284.55227 24098.418 24098.418 -1206.9224 -1206.9224 59000 -8043.1338 -8043.1338 -8120.4033 -8120.4033 299.04068 299.04068 24069.49 24069.49 1371.6813 1371.6813 Loop time of 100.322 on 1 procs for 1000 steps with 2000 atoms Performance: 0.861 ns/day, 27.867 hours/ns, 9.968 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.817 | 99.817 | 99.817 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076765 | 0.076765 | 0.076765 | 0.0 | 0.08 Output | 0.00015678 | 0.00015678 | 0.00015678 | 0.0 | 0.00 Modify | 0.37122 | 0.37122 | 0.37122 | 0.0 | 0.37 Other | | 0.05719 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116160.0 ave 116160 max 116160 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116160 Ave neighs/atom = 58.080000 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 = 293.207739915413, Press = 3.94814193860903 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 59000 -8043.1338 -8043.1338 -8120.4033 -8120.4033 299.04068 299.04068 24069.49 24069.49 1371.6813 1371.6813 60000 -8045.1709 -8045.1709 -8120.0624 -8120.0624 289.83784 289.83784 24103.87 24103.87 -1476.2237 -1476.2237 Loop time of 97.9764 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.216 hours/ns, 10.207 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 | 97.485 | 97.485 | 97.485 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075707 | 0.075707 | 0.075707 | 0.0 | 0.08 Output | 0.00019574 | 0.00019574 | 0.00019574 | 0.0 | 0.00 Modify | 0.35954 | 0.35954 | 0.35954 | 0.0 | 0.37 Other | | 0.05642 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.216056898757, Press = 1.57859360936497 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 60000 -8045.1709 -8045.1709 -8120.0624 -8120.0624 289.83784 289.83784 24103.87 24103.87 -1476.2237 -1476.2237 61000 -8043.2213 -8043.2213 -8118.7471 -8118.7471 292.29258 292.29258 24067.041 24067.041 1698.67 1698.67 Loop time of 99.1108 on 1 procs for 1000 steps with 2000 atoms Performance: 0.872 ns/day, 27.531 hours/ns, 10.090 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.609 | 98.609 | 98.609 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075903 | 0.075903 | 0.075903 | 0.0 | 0.08 Output | 0.00015478 | 0.00015478 | 0.00015478 | 0.0 | 0.00 Modify | 0.36851 | 0.36851 | 0.36851 | 0.0 | 0.37 Other | | 0.05733 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116184.0 ave 116184 max 116184 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116184 Ave neighs/atom = 58.092000 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 = 293.211812749728, Press = 2.81224823685846 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 61000 -8043.2213 -8043.2213 -8118.7471 -8118.7471 292.29258 292.29258 24067.041 24067.041 1698.67 1698.67 62000 -8045.7174 -8045.7174 -8120.7909 -8120.7909 290.54231 290.54231 24101.403 24101.403 -1287.5441 -1287.5441 Loop time of 97.8374 on 1 procs for 1000 steps with 2000 atoms Performance: 0.883 ns/day, 27.177 hours/ns, 10.221 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 | 97.344 | 97.344 | 97.344 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07529 | 0.07529 | 0.07529 | 0.0 | 0.08 Output | 0.00015488 | 0.00015488 | 0.00015488 | 0.0 | 0.00 Modify | 0.3616 | 0.3616 | 0.3616 | 0.0 | 0.37 Other | | 0.05672 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116148.0 ave 116148 max 116148 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116148 Ave neighs/atom = 58.074000 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 = 293.211601062462, Press = 1.66897345881568 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 62000 -8045.7174 -8045.7174 -8120.7909 -8120.7909 290.54231 290.54231 24101.403 24101.403 -1287.5441 -1287.5441 63000 -8042.239 -8042.239 -8120.5041 -8120.5041 302.8943 302.8943 24046.271 24046.271 3029.8506 3029.8506 Loop time of 98.6186 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.394 hours/ns, 10.140 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 | 98.12 | 98.12 | 98.12 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075756 | 0.075756 | 0.075756 | 0.0 | 0.08 Output | 0.00015342 | 0.00015342 | 0.00015342 | 0.0 | 0.00 Modify | 0.36531 | 0.36531 | 0.36531 | 0.0 | 0.37 Other | | 0.05694 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116150.0 ave 116150 max 116150 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116150 Ave neighs/atom = 58.075000 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 = 293.161200210542, Press = 3.0955290995054 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 63000 -8042.239 -8042.239 -8120.5041 -8120.5041 302.8943 302.8943 24046.271 24046.271 3029.8506 3029.8506 64000 -8044.3804 -8044.3804 -8118.9728 -8118.9728 288.68018 288.68018 24146.87 24146.87 -4556.203 -4556.203 Loop time of 100.203 on 1 procs for 1000 steps with 2000 atoms Performance: 0.862 ns/day, 27.834 hours/ns, 9.980 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.696 | 99.696 | 99.696 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075995 | 0.075995 | 0.075995 | 0.0 | 0.08 Output | 0.00019071 | 0.00019071 | 0.00019071 | 0.0 | 0.00 Modify | 0.37352 | 0.37352 | 0.37352 | 0.0 | 0.37 Other | | 0.05721 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116158.0 ave 116158 max 116158 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116158 Ave neighs/atom = 58.079000 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 = 293.164327686149, Press = 1.82120941900317 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 64000 -8044.3804 -8044.3804 -8118.9728 -8118.9728 288.68018 288.68018 24146.87 24146.87 -4556.203 -4556.203 65000 -8043.5309 -8043.5309 -8117.5651 -8117.5651 286.51974 286.51974 24052.708 24052.708 2763.8017 2763.8017 Loop time of 98.251 on 1 procs for 1000 steps with 2000 atoms Performance: 0.879 ns/day, 27.292 hours/ns, 10.178 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 | 97.753 | 97.753 | 97.753 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076182 | 0.076182 | 0.076182 | 0.0 | 0.08 Output | 0.00015486 | 0.00015486 | 0.00015486 | 0.0 | 0.00 Modify | 0.36447 | 0.36447 | 0.36447 | 0.0 | 0.37 Other | | 0.0574 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116172.0 ave 116172 max 116172 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116172 Ave neighs/atom = 58.086000 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 = 293.213492766566, Press = 2.37099094928332 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 65000 -8043.5309 -8043.5309 -8117.5651 -8117.5651 286.51974 286.51974 24052.708 24052.708 2763.8017 2763.8017 66000 -8042.0569 -8042.0569 -8118.7323 -8118.7323 296.74174 296.74174 24103.856 24103.856 -1189.085 -1189.085 Loop time of 99.0144 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.504 hours/ns, 10.100 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 | 98.517 | 98.517 | 98.517 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075601 | 0.075601 | 0.075601 | 0.0 | 0.08 Output | 0.00015058 | 0.00015058 | 0.00015058 | 0.0 | 0.00 Modify | 0.36427 | 0.36427 | 0.36427 | 0.0 | 0.37 Other | | 0.0571 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116200.0 ave 116200 max 116200 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116200 Ave neighs/atom = 58.100000 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 = 293.227629179593, Press = 2.50180194634426 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 66000 -8042.0569 -8042.0569 -8118.7323 -8118.7323 296.74174 296.74174 24103.856 24103.856 -1189.085 -1189.085 67000 -8045.8511 -8045.8511 -8121.6439 -8121.6439 293.32594 293.32594 24071.847 24071.847 809.69893 809.69893 Loop time of 98.45 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.347 hours/ns, 10.157 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 | 97.953 | 97.953 | 97.953 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075383 | 0.075383 | 0.075383 | 0.0 | 0.08 Output | 0.00015485 | 0.00015485 | 0.00015485 | 0.0 | 0.00 Modify | 0.36438 | 0.36438 | 0.36438 | 0.0 | 0.37 Other | | 0.05718 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116208.0 ave 116208 max 116208 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116208 Ave neighs/atom = 58.104000 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 = 293.2510219472, Press = 1.94583141151315 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 67000 -8045.8511 -8045.8511 -8121.6439 -8121.6439 293.32594 293.32594 24071.847 24071.847 809.69893 809.69893 68000 -8045.9489 -8045.9489 -8119.2811 -8119.2811 283.80344 283.80344 24114.113 24114.113 -2196.4168 -2196.4168 Loop time of 98.9837 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.495 hours/ns, 10.103 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 | 98.484 | 98.484 | 98.484 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076056 | 0.076056 | 0.076056 | 0.0 | 0.08 Output | 0.00015518 | 0.00015518 | 0.00015518 | 0.0 | 0.00 Modify | 0.36649 | 0.36649 | 0.36649 | 0.0 | 0.37 Other | | 0.05723 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116158.0 ave 116158 max 116158 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116158 Ave neighs/atom = 58.079000 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 = 293.24123700606, Press = 2.73791286328027 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 68000 -8045.9489 -8045.9489 -8119.2811 -8119.2811 283.80344 283.80344 24114.113 24114.113 -2196.4168 -2196.4168 69000 -8045.9873 -8045.9873 -8119.3474 -8119.3474 283.91116 283.91116 24046.109 24046.109 2989.7531 2989.7531 Loop time of 101.379 on 1 procs for 1000 steps with 2000 atoms Performance: 0.852 ns/day, 28.161 hours/ns, 9.864 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.87 | 100.87 | 100.87 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.078218 | 0.078218 | 0.078218 | 0.0 | 0.08 Output | 0.00015461 | 0.00015461 | 0.00015461 | 0.0 | 0.00 Modify | 0.37723 | 0.37723 | 0.37723 | 0.0 | 0.37 Other | | 0.05796 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116170.0 ave 116170 max 116170 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116170 Ave neighs/atom = 58.085000 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 = 293.224604604764, Press = 0.84063155106166 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 69000 -8045.9873 -8045.9873 -8119.3474 -8119.3474 283.91116 283.91116 24046.109 24046.109 2989.7531 2989.7531 70000 -8041.6013 -8041.6013 -8117.6199 -8117.6199 294.19997 294.19997 24108.889 24108.889 -1505.8262 -1505.8262 Loop time of 98.4523 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.348 hours/ns, 10.157 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 | 97.953 | 97.953 | 97.953 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076371 | 0.076371 | 0.076371 | 0.0 | 0.08 Output | 0.00015557 | 0.00015557 | 0.00015557 | 0.0 | 0.00 Modify | 0.36526 | 0.36526 | 0.36526 | 0.0 | 0.37 Other | | 0.05737 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116222.0 ave 116222 max 116222 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116222 Ave neighs/atom = 58.111000 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 = 293.253104247378, Press = 3.30410648909864 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 70000 -8041.6013 -8041.6013 -8117.6199 -8117.6199 294.19997 294.19997 24108.889 24108.889 -1505.8262 -1505.8262 71000 -8044.7032 -8044.7032 -8118.8886 -8118.8886 287.10528 287.10528 24080.735 24080.735 417.71852 417.71852 Loop time of 101.008 on 1 procs for 1000 steps with 2000 atoms Performance: 0.855 ns/day, 28.058 hours/ns, 9.900 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 100.5 | 100.5 | 100.5 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.078312 | 0.078312 | 0.078312 | 0.0 | 0.08 Output | 0.00018215 | 0.00018215 | 0.00018215 | 0.0 | 0.00 Modify | 0.37651 | 0.37651 | 0.37651 | 0.0 | 0.37 Other | | 0.05825 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.274200907352, Press = 1.27478600050275 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 71000 -8044.7032 -8044.7032 -8118.8886 -8118.8886 287.10528 287.10528 24080.735 24080.735 417.71852 417.71852 72000 -8037.6715 -8037.6715 -8115.9688 -8115.9688 303.0184 303.0184 24090.025 24090.025 251.91551 251.91551 Loop time of 98.4628 on 1 procs for 1000 steps with 2000 atoms Performance: 0.877 ns/day, 27.351 hours/ns, 10.156 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 | 97.965 | 97.965 | 97.965 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075982 | 0.075982 | 0.075982 | 0.0 | 0.08 Output | 0.00019188 | 0.00019188 | 0.00019188 | 0.0 | 0.00 Modify | 0.3649 | 0.3649 | 0.3649 | 0.0 | 0.37 Other | | 0.05717 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116236.0 ave 116236 max 116236 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116236 Ave neighs/atom = 58.118000 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 = 293.312817280419, Press = 2.88405085632367 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 72000 -8037.6715 -8037.6715 -8115.9688 -8115.9688 303.0184 303.0184 24090.025 24090.025 251.91551 251.91551 73000 -8045.0796 -8045.0796 -8119.2912 -8119.2912 287.20656 287.20656 24091.03 24091.03 -538.51094 -538.51094 Loop time of 98.5746 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.382 hours/ns, 10.145 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 | 98.075 | 98.075 | 98.075 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076024 | 0.076024 | 0.076024 | 0.0 | 0.08 Output | 0.0002024 | 0.0002024 | 0.0002024 | 0.0 | 0.00 Modify | 0.36651 | 0.36651 | 0.36651 | 0.0 | 0.37 Other | | 0.0573 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116234.0 ave 116234 max 116234 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116234 Ave neighs/atom = 58.117000 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 = 293.325210548441, Press = 1.2930896790951 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 73000 -8045.0796 -8045.0796 -8119.2912 -8119.2912 287.20656 287.20656 24091.03 24091.03 -538.51094 -538.51094 74000 -8040.2567 -8040.2567 -8117.9265 -8117.9265 300.59013 300.59013 24081.923 24081.923 604.06952 604.06952 Loop time of 97.7305 on 1 procs for 1000 steps with 2000 atoms Performance: 0.884 ns/day, 27.147 hours/ns, 10.232 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 | 97.238 | 97.238 | 97.238 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075228 | 0.075228 | 0.075228 | 0.0 | 0.08 Output | 0.00015423 | 0.00015423 | 0.00015423 | 0.0 | 0.00 Modify | 0.36026 | 0.36026 | 0.36026 | 0.0 | 0.37 Other | | 0.05738 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116202.0 ave 116202 max 116202 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116202 Ave neighs/atom = 58.101000 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 = 293.351173767181, Press = 2.57246930599331 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 74000 -8040.2567 -8040.2567 -8117.9265 -8117.9265 300.59013 300.59013 24081.923 24081.923 604.06952 604.06952 75000 -8044.9577 -8044.9577 -8120.2838 -8120.2838 291.51973 291.51973 24085.219 24085.219 -80.461583 -80.461583 Loop time of 99.1123 on 1 procs for 1000 steps with 2000 atoms Performance: 0.872 ns/day, 27.531 hours/ns, 10.090 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 98.606 | 98.606 | 98.606 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075834 | 0.075834 | 0.075834 | 0.0 | 0.08 Output | 0.00020026 | 0.00020026 | 0.00020026 | 0.0 | 0.00 Modify | 0.37266 | 0.37266 | 0.37266 | 0.0 | 0.38 Other | | 0.05741 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116194.0 ave 116194 max 116194 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116194 Ave neighs/atom = 58.097000 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 = 293.358997402949, Press = 1.73077940415523 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 75000 -8044.9577 -8044.9577 -8120.2838 -8120.2838 291.51973 291.51973 24085.219 24085.219 -80.461583 -80.461583 76000 -8043.388 -8043.388 -8119.1353 -8119.1353 293.15019 293.15019 24075.455 24075.455 870.1687 870.1687 Loop time of 99.9459 on 1 procs for 1000 steps with 2000 atoms Performance: 0.864 ns/day, 27.763 hours/ns, 10.005 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.44 | 99.44 | 99.44 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076371 | 0.076371 | 0.076371 | 0.0 | 0.08 Output | 0.00015317 | 0.00015317 | 0.00015317 | 0.0 | 0.00 Modify | 0.37194 | 0.37194 | 0.37194 | 0.0 | 0.37 Other | | 0.0576 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116176.0 ave 116176 max 116176 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116176 Ave neighs/atom = 58.088000 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 = 293.349062480278, Press = 2.09161742430296 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 76000 -8043.388 -8043.388 -8119.1353 -8119.1353 293.15019 293.15019 24075.455 24075.455 870.1687 870.1687 77000 -8041.3638 -8041.3638 -8119.1762 -8119.1762 301.14211 301.14211 24110.285 24110.285 -1720.9923 -1720.9923 Loop time of 98.9533 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.487 hours/ns, 10.106 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 | 98.455 | 98.455 | 98.455 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074659 | 0.074659 | 0.074659 | 0.0 | 0.08 Output | 0.00015409 | 0.00015409 | 0.00015409 | 0.0 | 0.00 Modify | 0.36674 | 0.36674 | 0.36674 | 0.0 | 0.37 Other | | 0.05706 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116164.0 ave 116164 max 116164 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116164 Ave neighs/atom = 58.082000 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 = 293.338370357886, Press = 1.77440993657167 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 77000 -8041.3638 -8041.3638 -8119.1762 -8119.1762 301.14211 301.14211 24110.285 24110.285 -1720.9923 -1720.9923 78000 -8045.0654 -8045.0654 -8120.059 -8120.059 290.23329 290.23329 24039.427 24039.427 3464.5792 3464.5792 Loop time of 98.4134 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.337 hours/ns, 10.161 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 | 97.915 | 97.915 | 97.915 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075685 | 0.075685 | 0.075685 | 0.0 | 0.08 Output | 0.00015329 | 0.00015329 | 0.00015329 | 0.0 | 0.00 Modify | 0.36529 | 0.36529 | 0.36529 | 0.0 | 0.37 Other | | 0.05713 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116152.0 ave 116152 max 116152 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116152 Ave neighs/atom = 58.076000 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 = 293.352739875683, Press = 1.83278628226503 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 78000 -8045.0654 -8045.0654 -8120.059 -8120.059 290.23329 290.23329 24039.427 24039.427 3464.5792 3464.5792 79000 -8041.7093 -8041.7093 -8118.6607 -8118.6607 297.81 297.81 24126.237 24126.237 -2970.0983 -2970.0983 Loop time of 99.8605 on 1 procs for 1000 steps with 2000 atoms Performance: 0.865 ns/day, 27.739 hours/ns, 10.014 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.352 | 99.352 | 99.352 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.076827 | 0.076827 | 0.076827 | 0.0 | 0.08 Output | 0.00015678 | 0.00015678 | 0.00015678 | 0.0 | 0.00 Modify | 0.37383 | 0.37383 | 0.37383 | 0.0 | 0.37 Other | | 0.05756 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2947.00 ave 2947 max 2947 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116200.0 ave 116200 max 116200 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116200 Ave neighs/atom = 58.100000 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 = 293.384973475244, Press = 2.20318043662206 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 79000 -8041.7093 -8041.7093 -8118.6607 -8118.6607 297.81 297.81 24126.237 24126.237 -2970.0983 -2970.0983 80000 -8043.2576 -8043.2576 -8119.0471 -8119.0471 293.31307 293.31307 24058.911 24058.911 2056.9505 2056.9505 Loop time of 97.3374 on 1 procs for 1000 steps with 2000 atoms Performance: 0.888 ns/day, 27.038 hours/ns, 10.274 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 | 96.849 | 96.849 | 96.849 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.073733 | 0.073733 | 0.073733 | 0.0 | 0.08 Output | 0.00015276 | 0.00015276 | 0.00015276 | 0.0 | 0.00 Modify | 0.35822 | 0.35822 | 0.35822 | 0.0 | 0.37 Other | | 0.05605 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116174.0 ave 116174 max 116174 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116174 Ave neighs/atom = 58.087000 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 = 293.392653119122, Press = 1.47073035107366 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 80000 -8043.2576 -8043.2576 -8119.0471 -8119.0471 293.31307 293.31307 24058.911 24058.911 2056.9505 2056.9505 81000 -8046.9206 -8046.9206 -8120.6393 -8120.6393 285.29908 285.29908 24094.18 24094.18 -940.9789 -940.9789 Loop time of 99.9136 on 1 procs for 1000 steps with 2000 atoms Performance: 0.865 ns/day, 27.754 hours/ns, 10.009 timesteps/s 99.8% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.408 | 99.408 | 99.408 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075699 | 0.075699 | 0.075699 | 0.0 | 0.08 Output | 0.00015597 | 0.00015597 | 0.00015597 | 0.0 | 0.00 Modify | 0.37207 | 0.37207 | 0.37207 | 0.0 | 0.37 Other | | 0.05798 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116210.0 ave 116210 max 116210 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116210 Ave neighs/atom = 58.105000 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 = 293.387250118776, Press = 2.20926436828071 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 81000 -8046.9206 -8046.9206 -8120.6393 -8120.6393 285.29908 285.29908 24094.18 24094.18 -940.9789 -940.9789 82000 -8042.9601 -8042.9601 -8120.2356 -8120.2356 299.06412 299.06412 24082.049 24082.049 289.34063 289.34063 Loop time of 98.9623 on 1 procs for 1000 steps with 2000 atoms Performance: 0.873 ns/day, 27.490 hours/ns, 10.105 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 | 98.461 | 98.461 | 98.461 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074892 | 0.074892 | 0.074892 | 0.0 | 0.08 Output | 0.00015541 | 0.00015541 | 0.00015541 | 0.0 | 0.00 Modify | 0.36984 | 0.36984 | 0.36984 | 0.0 | 0.37 Other | | 0.05687 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116204.0 ave 116204 max 116204 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116204 Ave neighs/atom = 58.102000 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 = 293.362203590088, Press = 1.60277019077737 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 82000 -8042.9601 -8042.9601 -8120.2356 -8120.2356 299.06412 299.06412 24082.049 24082.049 289.34063 289.34063 83000 -8044.552 -8044.552 -8121.393 -8121.393 297.38228 297.38228 24088.625 24088.625 -509.14245 -509.14245 Loop time of 98.5217 on 1 procs for 1000 steps with 2000 atoms Performance: 0.877 ns/day, 27.367 hours/ns, 10.150 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 | 98.02 | 98.02 | 98.02 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075388 | 0.075388 | 0.075388 | 0.0 | 0.08 Output | 0.00015447 | 0.00015447 | 0.00015447 | 0.0 | 0.00 Modify | 0.36891 | 0.36891 | 0.36891 | 0.0 | 0.37 Other | | 0.05708 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116176.0 ave 116176 max 116176 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116176 Ave neighs/atom = 58.088000 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 = 293.363912874749, Press = 1.84574827944329 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 83000 -8044.552 -8044.552 -8121.393 -8121.393 297.38228 297.38228 24088.625 24088.625 -509.14245 -509.14245 84000 -8042.341 -8042.341 -8118.3724 -8118.3724 294.24953 294.24953 24088.837 24088.837 -46.626422 -46.626422 Loop time of 98.7562 on 1 procs for 1000 steps with 2000 atoms Performance: 0.875 ns/day, 27.432 hours/ns, 10.126 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 | 98.255 | 98.255 | 98.255 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.0752 | 0.0752 | 0.0752 | 0.0 | 0.08 Output | 0.00015133 | 0.00015133 | 0.00015133 | 0.0 | 0.00 Modify | 0.36959 | 0.36959 | 0.36959 | 0.0 | 0.37 Other | | 0.05677 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116178.0 ave 116178 max 116178 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116178 Ave neighs/atom = 58.089000 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 = 293.344427368656, Press = 1.67279100075726 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 84000 -8042.341 -8042.341 -8118.3724 -8118.3724 294.24953 294.24953 24088.837 24088.837 -46.626422 -46.626422 85000 -8046.7169 -8046.7169 -8121.6272 -8121.6272 289.91058 289.91058 24080.925 24080.925 3.0405092 3.0405092 Loop time of 99.6271 on 1 procs for 1000 steps with 2000 atoms Performance: 0.867 ns/day, 27.674 hours/ns, 10.037 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.125 | 99.125 | 99.125 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075499 | 0.075499 | 0.075499 | 0.0 | 0.08 Output | 0.00015397 | 0.00015397 | 0.00015397 | 0.0 | 0.00 Modify | 0.36956 | 0.36956 | 0.36956 | 0.0 | 0.37 Other | | 0.05713 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116186.0 ave 116186 max 116186 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116186 Ave neighs/atom = 58.093000 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 = 293.329583563078, Press = 1.48277517684734 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 85000 -8046.7169 -8046.7169 -8121.6272 -8121.6272 289.91058 289.91058 24080.925 24080.925 3.0405092 3.0405092 86000 -8042.1075 -8042.1075 -8118.0135 -8118.0135 293.76409 293.76409 24084.568 24084.568 331.98302 331.98302 Loop time of 98.2117 on 1 procs for 1000 steps with 2000 atoms Performance: 0.880 ns/day, 27.281 hours/ns, 10.182 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 | 97.718 | 97.718 | 97.718 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074812 | 0.074812 | 0.074812 | 0.0 | 0.08 Output | 0.00015568 | 0.00015568 | 0.00015568 | 0.0 | 0.00 Modify | 0.36204 | 0.36204 | 0.36204 | 0.0 | 0.37 Other | | 0.05667 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116194.0 ave 116194 max 116194 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116194 Ave neighs/atom = 58.097000 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 = 293.314631621125, Press = 1.99552947137974 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 86000 -8042.1075 -8042.1075 -8118.0135 -8118.0135 293.76409 293.76409 24084.568 24084.568 331.98302 331.98302 87000 -8046.9848 -8046.9848 -8120.4802 -8120.4802 284.43484 284.43484 24096.305 24096.305 -1024.5772 -1024.5772 Loop time of 98.2989 on 1 procs for 1000 steps with 2000 atoms Performance: 0.879 ns/day, 27.305 hours/ns, 10.173 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 | 97.8 | 97.8 | 97.8 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075113 | 0.075113 | 0.075113 | 0.0 | 0.08 Output | 0.00016321 | 0.00016321 | 0.00016321 | 0.0 | 0.00 Modify | 0.36687 | 0.36687 | 0.36687 | 0.0 | 0.37 Other | | 0.0567 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116192.0 ave 116192 max 116192 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116192 Ave neighs/atom = 58.096000 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 = 293.298025029989, Press = 1.14871634694952 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 87000 -8046.9848 -8046.9848 -8120.4802 -8120.4802 284.43484 284.43484 24096.305 24096.305 -1024.5772 -1024.5772 88000 -8042.6204 -8042.6204 -8118.4577 -8118.4577 293.49844 293.49844 24061.009 24061.009 2057.5998 2057.5998 Loop time of 100.085 on 1 procs for 1000 steps with 2000 atoms Performance: 0.863 ns/day, 27.801 hours/ns, 9.992 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.579 | 99.579 | 99.579 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075389 | 0.075389 | 0.075389 | 0.0 | 0.08 Output | 0.00015544 | 0.00015544 | 0.00015544 | 0.0 | 0.00 Modify | 0.37234 | 0.37234 | 0.37234 | 0.0 | 0.37 Other | | 0.05731 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116168.0 ave 116168 max 116168 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116168 Ave neighs/atom = 58.084000 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 = 293.278449429877, Press = 1.96940367176936 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 88000 -8042.6204 -8042.6204 -8118.4577 -8118.4577 293.49844 293.49844 24061.009 24061.009 2057.5998 2057.5998 89000 -8044.4699 -8044.4699 -8119.4553 -8119.4553 290.20129 290.20129 24131.132 24131.132 -3368.8965 -3368.8965 Loop time of 99.6853 on 1 procs for 1000 steps with 2000 atoms Performance: 0.867 ns/day, 27.690 hours/ns, 10.032 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 99.179 | 99.179 | 99.179 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075562 | 0.075562 | 0.075562 | 0.0 | 0.08 Output | 0.00015451 | 0.00015451 | 0.00015451 | 0.0 | 0.00 Modify | 0.37245 | 0.37245 | 0.37245 | 0.0 | 0.37 Other | | 0.05799 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116212.0 ave 116212 max 116212 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116212 Ave neighs/atom = 58.106000 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 = 293.284301853977, Press = 1.34418062136134 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 89000 -8044.4699 -8044.4699 -8119.4553 -8119.4553 290.20129 290.20129 24131.132 24131.132 -3368.8965 -3368.8965 90000 -8044.0275 -8044.0275 -8118.9541 -8118.9541 289.97339 289.97339 24041.111 24041.111 3579.9366 3579.9366 Loop time of 98.2937 on 1 procs for 1000 steps with 2000 atoms Performance: 0.879 ns/day, 27.304 hours/ns, 10.174 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 | 97.799 | 97.799 | 97.799 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074676 | 0.074676 | 0.074676 | 0.0 | 0.08 Output | 0.00015742 | 0.00015742 | 0.00015742 | 0.0 | 0.00 Modify | 0.3632 | 0.3632 | 0.3632 | 0.0 | 0.37 Other | | 0.0567 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116190.0 ave 116190 max 116190 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116190 Ave neighs/atom = 58.095000 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 = 293.278734120493, Press = 1.61631903921457 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 90000 -8044.0275 -8044.0275 -8118.9541 -8118.9541 289.97339 289.97339 24041.111 24041.111 3579.9366 3579.9366 91000 -8043.3076 -8043.3076 -8119.143 -8119.143 293.49078 293.49078 24103.832 24103.832 -1254.8001 -1254.8001 Loop time of 98.741 on 1 procs for 1000 steps with 2000 atoms Performance: 0.875 ns/day, 27.428 hours/ns, 10.128 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 | 98.239 | 98.239 | 98.239 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075454 | 0.075454 | 0.075454 | 0.0 | 0.08 Output | 0.00015566 | 0.00015566 | 0.00015566 | 0.0 | 0.00 Modify | 0.36936 | 0.36936 | 0.36936 | 0.0 | 0.37 Other | | 0.05675 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116240.0 ave 116240 max 116240 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116240 Ave neighs/atom = 58.120000 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 = 293.295080837696, Press = 1.46622906198301 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 91000 -8043.3076 -8043.3076 -8119.143 -8119.143 293.49078 293.49078 24103.832 24103.832 -1254.8001 -1254.8001 92000 -8048.1472 -8048.1472 -8121.6586 -8121.6586 284.49635 284.49635 24067.498 24067.498 1065.4045 1065.4045 Loop time of 97.2892 on 1 procs for 1000 steps with 2000 atoms Performance: 0.888 ns/day, 27.025 hours/ns, 10.279 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 | 96.797 | 96.797 | 96.797 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074915 | 0.074915 | 0.074915 | 0.0 | 0.08 Output | 0.00015398 | 0.00015398 | 0.00015398 | 0.0 | 0.00 Modify | 0.36029 | 0.36029 | 0.36029 | 0.0 | 0.37 Other | | 0.05647 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116208.0 ave 116208 max 116208 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116208 Ave neighs/atom = 58.104000 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 = 293.263296054455, Press = 1.43643818840981 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 92000 -8048.1472 -8048.1472 -8121.6586 -8121.6586 284.49635 284.49635 24067.498 24067.498 1065.4045 1065.4045 93000 -8043.6828 -8043.6828 -8119.5366 -8119.5366 293.56223 293.56223 24099.187 24099.187 -965.975 -965.975 Loop time of 97.7459 on 1 procs for 1000 steps with 2000 atoms Performance: 0.884 ns/day, 27.152 hours/ns, 10.231 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 | 97.252 | 97.252 | 97.252 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074502 | 0.074502 | 0.074502 | 0.0 | 0.08 Output | 0.00015448 | 0.00015448 | 0.00015448 | 0.0 | 0.00 Modify | 0.36232 | 0.36232 | 0.36232 | 0.0 | 0.37 Other | | 0.05688 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116220.0 ave 116220 max 116220 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116220 Ave neighs/atom = 58.110000 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 = 293.2580173832, Press = 1.63638937552128 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 93000 -8043.6828 -8043.6828 -8119.5366 -8119.5366 293.56223 293.56223 24099.187 24099.187 -965.975 -965.975 94000 -8042.4893 -8042.4893 -8118.911 -8118.911 295.76 295.76 24073.405 24073.405 1057.9866 1057.9866 Loop time of 98.2685 on 1 procs for 1000 steps with 2000 atoms Performance: 0.879 ns/day, 27.297 hours/ns, 10.176 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 | 97.773 | 97.773 | 97.773 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074526 | 0.074526 | 0.074526 | 0.0 | 0.08 Output | 0.00015464 | 0.00015464 | 0.00015464 | 0.0 | 0.00 Modify | 0.3646 | 0.3646 | 0.3646 | 0.0 | 0.37 Other | | 0.05642 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116172.0 ave 116172 max 116172 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116172 Ave neighs/atom = 58.086000 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 = 293.256568512291, Press = 0.805144863229671 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 94000 -8042.4893 -8042.4893 -8118.911 -8118.911 295.76 295.76 24073.405 24073.405 1057.9866 1057.9866 95000 -8042.5069 -8042.5069 -8117.6556 -8117.6556 290.83312 290.83312 24090.549 24090.549 -59.072383 -59.072383 Loop time of 96.8759 on 1 procs for 1000 steps with 2000 atoms Performance: 0.892 ns/day, 26.910 hours/ns, 10.322 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 | 96.391 | 96.391 | 96.391 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.073621 | 0.073621 | 0.073621 | 0.0 | 0.08 Output | 0.00015521 | 0.00015521 | 0.00015521 | 0.0 | 0.00 Modify | 0.3552 | 0.3552 | 0.3552 | 0.0 | 0.37 Other | | 0.05606 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116222.0 ave 116222 max 116222 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116222 Ave neighs/atom = 58.111000 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 = 293.288166371015, Press = 2.32810808413703 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 95000 -8042.5069 -8042.5069 -8117.6556 -8117.6556 290.83312 290.83312 24090.549 24090.549 -59.072383 -59.072383 96000 -8047.8263 -8047.8263 -8121.6751 -8121.6751 285.80234 285.80234 24085.406 24085.406 -272.55978 -272.55978 Loop time of 98.4309 on 1 procs for 1000 steps with 2000 atoms Performance: 0.878 ns/day, 27.342 hours/ns, 10.159 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 | 97.936 | 97.936 | 97.936 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074318 | 0.074318 | 0.074318 | 0.0 | 0.08 Output | 0.00016111 | 0.00016111 | 0.00016111 | 0.0 | 0.00 Modify | 0.36373 | 0.36373 | 0.36373 | 0.0 | 0.37 Other | | 0.05661 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2947.00 ave 2947 max 2947 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116246.0 ave 116246 max 116246 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116246 Ave neighs/atom = 58.123000 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 = 293.270630371316, Press = 0.728740616039884 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 96000 -8047.8263 -8047.8263 -8121.6751 -8121.6751 285.80234 285.80234 24085.406 24085.406 -272.55978 -272.55978 97000 -8042.6642 -8042.6642 -8118.2602 -8118.2602 292.56417 292.56417 24078.926 24078.926 738.69461 738.69461 Loop time of 97.4923 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.081 hours/ns, 10.257 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 | 97 | 97 | 97 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074397 | 0.074397 | 0.074397 | 0.0 | 0.08 Output | 0.00015339 | 0.00015339 | 0.00015339 | 0.0 | 0.00 Modify | 0.36118 | 0.36118 | 0.36118 | 0.0 | 0.37 Other | | 0.05682 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116162.0 ave 116162 max 116162 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116162 Ave neighs/atom = 58.081000 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 = 293.255817229215, Press = 2.09255561270839 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 97000 -8042.6642 -8042.6642 -8118.2602 -8118.2602 292.56417 292.56417 24078.926 24078.926 738.69461 738.69461 98000 -8039.6054 -8039.6054 -8118.9532 -8118.9532 307.08408 307.08408 24102.15 24102.15 -977.25122 -977.25122 Loop time of 97.501 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.084 hours/ns, 10.256 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 | 97.01 | 97.01 | 97.01 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07382 | 0.07382 | 0.07382 | 0.0 | 0.08 Output | 0.00015451 | 0.00015451 | 0.00015451 | 0.0 | 0.00 Modify | 0.36061 | 0.36061 | 0.36061 | 0.0 | 0.37 Other | | 0.05594 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116246.0 ave 116246 max 116246 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116246 Ave neighs/atom = 58.123000 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 = 293.267431002518, Press = 1.02770455183285 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 98000 -8039.6054 -8039.6054 -8118.9532 -8118.9532 307.08408 307.08408 24102.15 24102.15 -977.25122 -977.25122 99000 -8044.5091 -8044.5091 -8120.3343 -8120.3343 293.45156 293.45156 24078.693 24078.693 491.31563 491.31563 Loop time of 99.32 on 1 procs for 1000 steps with 2000 atoms Performance: 0.870 ns/day, 27.589 hours/ns, 10.068 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 | 98.816 | 98.816 | 98.816 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075792 | 0.075792 | 0.075792 | 0.0 | 0.08 Output | 0.00021268 | 0.00021268 | 0.00021268 | 0.0 | 0.00 Modify | 0.37117 | 0.37117 | 0.37117 | 0.0 | 0.37 Other | | 0.05666 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116196.0 ave 116196 max 116196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116196 Ave neighs/atom = 58.098000 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 = 293.28234793601, Press = 1.58470516953471 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 99000 -8044.5091 -8044.5091 -8120.3343 -8120.3343 293.45156 293.45156 24078.693 24078.693 491.31563 491.31563 100000 -8046.3651 -8046.3651 -8120.3481 -8120.3481 286.32167 286.32167 24091.191 24091.191 -545.10363 -545.10363 Loop time of 96.878 on 1 procs for 1000 steps with 2000 atoms Performance: 0.892 ns/day, 26.911 hours/ns, 10.322 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 | 96.388 | 96.388 | 96.388 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.073798 | 0.073798 | 0.073798 | 0.0 | 0.08 Output | 0.00015085 | 0.00015085 | 0.00015085 | 0.0 | 0.00 Modify | 0.35989 | 0.35989 | 0.35989 | 0.0 | 0.37 Other | | 0.05594 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116208.0 ave 116208 max 116208 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116208 Ave neighs/atom = 58.104000 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 = 293.286398358874, Press = 1.18874447002312 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 100000 -8046.3651 -8046.3651 -8120.3481 -8120.3481 286.32167 286.32167 24091.191 24091.191 -545.10363 -545.10363 101000 -8044.3382 -8044.3382 -8119.1633 -8119.1633 289.5808 289.5808 24073.48 24073.48 933.13456 933.13456 Loop time of 97.5976 on 1 procs for 1000 steps with 2000 atoms Performance: 0.885 ns/day, 27.110 hours/ns, 10.246 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 | 97.103 | 97.103 | 97.103 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074599 | 0.074599 | 0.074599 | 0.0 | 0.08 Output | 0.00015501 | 0.00015501 | 0.00015501 | 0.0 | 0.00 Modify | 0.36389 | 0.36389 | 0.36389 | 0.0 | 0.37 Other | | 0.05622 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116208.0 ave 116208 max 116208 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116208 Ave neighs/atom = 58.104000 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 = 293.252156865725, Press = 1.290543695717 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 101000 -8044.3382 -8044.3382 -8119.1633 -8119.1633 289.5808 289.5808 24073.48 24073.48 933.13456 933.13456 102000 -8044.8982 -8044.8982 -8119.4048 -8119.4048 288.34839 288.34839 24116.318 24116.318 -2330.1411 -2330.1411 Loop time of 97.4748 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.076 hours/ns, 10.259 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 | 96.98 | 96.98 | 96.98 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075026 | 0.075026 | 0.075026 | 0.0 | 0.08 Output | 0.00015655 | 0.00015655 | 0.00015655 | 0.0 | 0.00 Modify | 0.36279 | 0.36279 | 0.36279 | 0.0 | 0.37 Other | | 0.05672 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116202.0 ave 116202 max 116202 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116202 Ave neighs/atom = 58.101000 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 = 293.249685919782, Press = 1.25393631652644 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 102000 -8044.8982 -8044.8982 -8119.4048 -8119.4048 288.34839 288.34839 24116.318 24116.318 -2330.1411 -2330.1411 103000 -8044.3576 -8044.3576 -8120.0065 -8120.0065 292.7692 292.7692 24052.973 24052.973 2644.7579 2644.7579 Loop time of 98.0551 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.238 hours/ns, 10.198 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 | 97.556 | 97.556 | 97.556 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074897 | 0.074897 | 0.074897 | 0.0 | 0.08 Output | 0.00015125 | 0.00015125 | 0.00015125 | 0.0 | 0.00 Modify | 0.3672 | 0.3672 | 0.3672 | 0.0 | 0.37 Other | | 0.05701 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116172.0 ave 116172 max 116172 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116172 Ave neighs/atom = 58.086000 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 = 293.227430635059, Press = 1.16291881602203 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 103000 -8044.3576 -8044.3576 -8120.0065 -8120.0065 292.7692 292.7692 24052.973 24052.973 2644.7579 2644.7579 104000 -8046.3846 -8046.3846 -8121.3996 -8121.3996 290.31589 290.31589 24115.978 24115.978 -2446.3183 -2446.3183 Loop time of 97.0926 on 1 procs for 1000 steps with 2000 atoms Performance: 0.890 ns/day, 26.970 hours/ns, 10.299 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 | 96.601 | 96.601 | 96.601 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074203 | 0.074203 | 0.074203 | 0.0 | 0.08 Output | 0.00015409 | 0.00015409 | 0.00015409 | 0.0 | 0.00 Modify | 0.36021 | 0.36021 | 0.36021 | 0.0 | 0.37 Other | | 0.05663 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116218.0 ave 116218 max 116218 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116218 Ave neighs/atom = 58.109000 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 = 293.218302660317, Press = 1.41165052293438 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 104000 -8046.3846 -8046.3846 -8121.3996 -8121.3996 290.31589 290.31589 24115.978 24115.978 -2446.3183 -2446.3183 105000 -8043.4699 -8043.4699 -8119.8859 -8119.8859 295.7376 295.7376 24056.338 24056.338 2316.9997 2316.9997 Loop time of 97.7729 on 1 procs for 1000 steps with 2000 atoms Performance: 0.884 ns/day, 27.159 hours/ns, 10.228 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 | 97.276 | 97.276 | 97.276 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075242 | 0.075242 | 0.075242 | 0.0 | 0.08 Output | 0.00015528 | 0.00015528 | 0.00015528 | 0.0 | 0.00 Modify | 0.36447 | 0.36447 | 0.36447 | 0.0 | 0.37 Other | | 0.05691 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2949.00 ave 2949 max 2949 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116170.0 ave 116170 max 116170 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116170 Ave neighs/atom = 58.085000 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 = 293.188326376682, Press = 0.916088660656584 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 105000 -8043.4699 -8043.4699 -8119.8859 -8119.8859 295.7376 295.7376 24056.338 24056.338 2316.9997 2316.9997 106000 -8046.9532 -8046.9532 -8121.5265 -8121.5265 288.60618 288.60618 24093.471 24093.471 -832.88312 -832.88312 Loop time of 97.6266 on 1 procs for 1000 steps with 2000 atoms Performance: 0.885 ns/day, 27.119 hours/ns, 10.243 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 | 97.132 | 97.132 | 97.132 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074964 | 0.074964 | 0.074964 | 0.0 | 0.08 Output | 0.00015417 | 0.00015417 | 0.00015417 | 0.0 | 0.00 Modify | 0.36271 | 0.36271 | 0.36271 | 0.0 | 0.37 Other | | 0.05685 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116220.0 ave 116220 max 116220 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116220 Ave neighs/atom = 58.110000 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 = 293.173347541418, Press = 1.54084373089048 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 106000 -8046.9532 -8046.9532 -8121.5265 -8121.5265 288.60618 288.60618 24093.471 24093.471 -832.88312 -832.88312 107000 -8042.037 -8042.037 -8118.1264 -8118.1264 294.47367 294.47367 24086.839 24086.839 141.44297 141.44297 Loop time of 96.8851 on 1 procs for 1000 steps with 2000 atoms Performance: 0.892 ns/day, 26.913 hours/ns, 10.322 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 | 96.395 | 96.395 | 96.395 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074144 | 0.074144 | 0.074144 | 0.0 | 0.08 Output | 0.00015191 | 0.00015191 | 0.00015191 | 0.0 | 0.00 Modify | 0.35982 | 0.35982 | 0.35982 | 0.0 | 0.37 Other | | 0.05612 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116166.0 ave 116166 max 116166 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116166 Ave neighs/atom = 58.083000 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 = 293.157307473979, Press = 1.07720122848786 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 107000 -8042.037 -8042.037 -8118.1264 -8118.1264 294.47367 294.47367 24086.839 24086.839 141.44297 141.44297 108000 -8040.9359 -8040.9359 -8119.5942 -8119.5942 304.4158 304.4158 24088.389 24088.389 17.538124 17.538124 Loop time of 97.7949 on 1 procs for 1000 steps with 2000 atoms Performance: 0.883 ns/day, 27.165 hours/ns, 10.225 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 | 97.302 | 97.302 | 97.302 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07462 | 0.07462 | 0.07462 | 0.0 | 0.08 Output | 0.00019975 | 0.00019975 | 0.00019975 | 0.0 | 0.00 Modify | 0.36145 | 0.36145 | 0.36145 | 0.0 | 0.37 Other | | 0.05652 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116188.0 ave 116188 max 116188 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116188 Ave neighs/atom = 58.094000 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 = 293.157893619827, Press = 1.24347217126999 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 108000 -8040.9359 -8040.9359 -8119.5942 -8119.5942 304.4158 304.4158 24088.389 24088.389 17.538124 17.538124 109000 -8043.9986 -8043.9986 -8117.821 -8117.821 285.70037 285.70037 24094.02 24094.02 -330.05941 -330.05941 Loop time of 98.1605 on 1 procs for 1000 steps with 2000 atoms Performance: 0.880 ns/day, 27.267 hours/ns, 10.187 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 97.665 | 97.665 | 97.665 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07496 | 0.07496 | 0.07496 | 0.0 | 0.08 Output | 0.00019285 | 0.00019285 | 0.00019285 | 0.0 | 0.00 Modify | 0.36411 | 0.36411 | 0.36411 | 0.0 | 0.37 Other | | 0.05678 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116174.0 ave 116174 max 116174 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116174 Ave neighs/atom = 58.087000 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 = 293.183883666129, Press = 1.16725188354083 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 109000 -8043.9986 -8043.9986 -8117.821 -8117.821 285.70037 285.70037 24094.02 24094.02 -330.05941 -330.05941 110000 -8042.6383 -8042.6383 -8118.3091 -8118.3091 292.85404 292.85404 24077.703 24077.703 1000.0444 1000.0444 Loop time of 96.6702 on 1 procs for 1000 steps with 2000 atoms Performance: 0.894 ns/day, 26.853 hours/ns, 10.344 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 | 96.182 | 96.182 | 96.182 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.073962 | 0.073962 | 0.073962 | 0.0 | 0.08 Output | 0.00015712 | 0.00015712 | 0.00015712 | 0.0 | 0.00 Modify | 0.3573 | 0.3573 | 0.3573 | 0.0 | 0.37 Other | | 0.05646 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116196.0 ave 116196 max 116196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116196 Ave neighs/atom = 58.098000 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 = 293.186927457151, Press = 1.07025074242845 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 110000 -8042.6383 -8042.6383 -8118.3091 -8118.3091 292.85404 292.85404 24077.703 24077.703 1000.0444 1000.0444 111000 -8041.774 -8041.774 -8118.4623 -8118.4623 296.79158 296.79158 24104.572 24104.572 -1084.0386 -1084.0386 Loop time of 97.9507 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.209 hours/ns, 10.209 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 | 97.455 | 97.455 | 97.455 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075116 | 0.075116 | 0.075116 | 0.0 | 0.08 Output | 0.00015367 | 0.00015367 | 0.00015367 | 0.0 | 0.00 Modify | 0.36314 | 0.36314 | 0.36314 | 0.0 | 0.37 Other | | 0.0569 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116198.0 ave 116198 max 116198 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116198 Ave neighs/atom = 58.099000 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 = 293.214612570999, Press = 1.16961683251319 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 111000 -8041.774 -8041.774 -8118.4623 -8118.4623 296.79158 296.79158 24104.572 24104.572 -1084.0386 -1084.0386 112000 -8044.9015 -8044.9015 -8121.4899 -8121.4899 296.40476 296.40476 24064.713 24064.713 1504.9347 1504.9347 Loop time of 98.0259 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.229 hours/ns, 10.201 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 | 97.534 | 97.534 | 97.534 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074172 | 0.074172 | 0.074172 | 0.0 | 0.08 Output | 0.0001572 | 0.0001572 | 0.0001572 | 0.0 | 0.00 Modify | 0.36197 | 0.36197 | 0.36197 | 0.0 | 0.37 Other | | 0.05609 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116174.0 ave 116174 max 116174 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116174 Ave neighs/atom = 58.087000 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 = 293.22578114961, Press = 0.838158092378294 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 112000 -8044.9015 -8044.9015 -8121.4899 -8121.4899 296.40476 296.40476 24064.713 24064.713 1504.9347 1504.9347 113000 -8045.8239 -8045.8239 -8119.5395 -8119.5395 285.28687 285.28687 24118.009 24118.009 -2471.3166 -2471.3166 Loop time of 98.191 on 1 procs for 1000 steps with 2000 atoms Performance: 0.880 ns/day, 27.275 hours/ns, 10.184 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 | 97.695 | 97.695 | 97.695 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07548 | 0.07548 | 0.07548 | 0.0 | 0.08 Output | 0.00019802 | 0.00019802 | 0.00019802 | 0.0 | 0.00 Modify | 0.36285 | 0.36285 | 0.36285 | 0.0 | 0.37 Other | | 0.05721 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116202.0 ave 116202 max 116202 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116202 Ave neighs/atom = 58.101000 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 = 293.237758020542, Press = 1.47036217360692 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 113000 -8045.8239 -8045.8239 -8119.5395 -8119.5395 285.28687 285.28687 24118.009 24118.009 -2471.3166 -2471.3166 114000 -8045.1625 -8045.1625 -8119.6657 -8119.6657 288.33529 288.33529 24062.768 24062.768 1849.9518 1849.9518 Loop time of 98.0116 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.225 hours/ns, 10.203 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 | 97.518 | 97.518 | 97.518 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074859 | 0.074859 | 0.074859 | 0.0 | 0.08 Output | 0.00015827 | 0.00015827 | 0.00015827 | 0.0 | 0.00 Modify | 0.36236 | 0.36236 | 0.36236 | 0.0 | 0.37 Other | | 0.05612 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116148.0 ave 116148 max 116148 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116148 Ave neighs/atom = 58.074000 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 = 293.217524922599, Press = 0.571071745302828 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 114000 -8045.1625 -8045.1625 -8119.6657 -8119.6657 288.33529 288.33529 24062.768 24062.768 1849.9518 1849.9518 115000 -8044.0636 -8044.0636 -8119.1582 -8119.1582 290.62398 290.62398 24097.663 24097.663 -746.6303 -746.6303 Loop time of 97.4013 on 1 procs for 1000 steps with 2000 atoms Performance: 0.887 ns/day, 27.056 hours/ns, 10.267 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 | 96.912 | 96.912 | 96.912 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074607 | 0.074607 | 0.074607 | 0.0 | 0.08 Output | 0.00015629 | 0.00015629 | 0.00015629 | 0.0 | 0.00 Modify | 0.3589 | 0.3589 | 0.3589 | 0.0 | 0.37 Other | | 0.05609 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116214.0 ave 116214 max 116214 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116214 Ave neighs/atom = 58.107000 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 = 293.207259573729, Press = 1.33388663996857 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 115000 -8044.0636 -8044.0636 -8119.1582 -8119.1582 290.62398 290.62398 24097.663 24097.663 -746.6303 -746.6303 116000 -8043.6802 -8043.6802 -8119.2622 -8119.2622 292.51021 292.51021 24081.003 24081.003 585.69254 585.69254 Loop time of 97.7529 on 1 procs for 1000 steps with 2000 atoms Performance: 0.884 ns/day, 27.154 hours/ns, 10.230 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 | 97.258 | 97.258 | 97.258 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074805 | 0.074805 | 0.074805 | 0.0 | 0.08 Output | 0.00019262 | 0.00019262 | 0.00019262 | 0.0 | 0.00 Modify | 0.36166 | 0.36166 | 0.36166 | 0.0 | 0.37 Other | | 0.05803 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116238.0 ave 116238 max 116238 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116238 Ave neighs/atom = 58.119000 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 = 293.20440387851, Press = 0.89392139077117 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 116000 -8043.6802 -8043.6802 -8119.2622 -8119.2622 292.51021 292.51021 24081.003 24081.003 585.69254 585.69254 117000 -8044.349 -8044.349 -8118.7191 -8118.7191 287.82016 287.82016 24089.11 24089.11 -135.5075 -135.5075 Loop time of 98.891 on 1 procs for 1000 steps with 2000 atoms Performance: 0.874 ns/day, 27.470 hours/ns, 10.112 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 | 98.389 | 98.389 | 98.389 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075738 | 0.075738 | 0.075738 | 0.0 | 0.08 Output | 0.00015274 | 0.00015274 | 0.00015274 | 0.0 | 0.00 Modify | 0.36858 | 0.36858 | 0.36858 | 0.0 | 0.37 Other | | 0.05703 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2946.00 ave 2946 max 2946 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116188.0 ave 116188 max 116188 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116188 Ave neighs/atom = 58.094000 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 = 293.229816671248, Press = 1.09443699892544 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 117000 -8044.349 -8044.349 -8118.7191 -8118.7191 287.82016 287.82016 24089.11 24089.11 -135.5075 -135.5075 118000 -8042.0282 -8042.0282 -8119.9241 -8119.9241 301.46507 301.46507 24093.564 24093.564 -401.74598 -401.74598 Loop time of 98.092 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.248 hours/ns, 10.195 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 | 97.597 | 97.597 | 97.597 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074972 | 0.074972 | 0.074972 | 0.0 | 0.08 Output | 0.00015497 | 0.00015497 | 0.00015497 | 0.0 | 0.00 Modify | 0.36302 | 0.36302 | 0.36302 | 0.0 | 0.37 Other | | 0.05651 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116204.0 ave 116204 max 116204 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116204 Ave neighs/atom = 58.102000 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 = 293.227568566274, Press = 0.883084475461851 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 118000 -8042.0282 -8042.0282 -8119.9241 -8119.9241 301.46507 301.46507 24093.564 24093.564 -401.74598 -401.74598 119000 -8047.4919 -8047.4919 -8121.1586 -8121.1586 285.09801 285.09801 24072.078 24072.078 953.24262 953.24262 Loop time of 97.9557 on 1 procs for 1000 steps with 2000 atoms Performance: 0.882 ns/day, 27.210 hours/ns, 10.209 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 | 97.459 | 97.459 | 97.459 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074718 | 0.074718 | 0.074718 | 0.0 | 0.08 Output | 0.00044957 | 0.00044957 | 0.00044957 | 0.0 | 0.00 Modify | 0.36441 | 0.36441 | 0.36441 | 0.0 | 0.37 Other | | 0.05732 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2945.00 ave 2945 max 2945 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116176.0 ave 116176 max 116176 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116176 Ave neighs/atom = 58.088000 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 = 293.202817703456, Press = 1.1651500921427 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 119000 -8047.4919 -8047.4919 -8121.1586 -8121.1586 285.09801 285.09801 24072.078 24072.078 953.24262 953.24262 120000 -8042.9664 -8042.9664 -8118.3972 -8118.3972 291.92518 291.92518 24100.81 24100.81 -831.17336 -831.17336 Loop time of 97.1814 on 1 procs for 1000 steps with 2000 atoms Performance: 0.889 ns/day, 26.995 hours/ns, 10.290 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 | 96.688 | 96.688 | 96.688 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074622 | 0.074622 | 0.074622 | 0.0 | 0.08 Output | 0.00015635 | 0.00015635 | 0.00015635 | 0.0 | 0.00 Modify | 0.36159 | 0.36159 | 0.36159 | 0.0 | 0.37 Other | | 0.05665 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2948.00 ave 2948 max 2948 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116212.0 ave 116212 max 116212 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116212 Ave neighs/atom = 58.106000 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 = 293.198808316352, Press = 0.853927627941689 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 120000 -8042.9664 -8042.9664 -8118.3972 -8118.3972 291.92518 291.92518 24100.81 24100.81 -831.17336 -831.17336 121000 -8046.2289 -8046.2289 -8121.4153 -8121.4153 290.97937 290.97937 24063.678 24063.678 1597.411 1597.411 Loop time of 97.9015 on 1 procs for 1000 steps with 2000 atoms Performance: 0.883 ns/day, 27.195 hours/ns, 10.214 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 | 97.406 | 97.406 | 97.406 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075192 | 0.075192 | 0.075192 | 0.0 | 0.08 Output | 0.00015919 | 0.00015919 | 0.00015919 | 0.0 | 0.00 Modify | 0.36401 | 0.36401 | 0.36401 | 0.0 | 0.37 Other | | 0.05657 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116190.0 ave 116190 max 116190 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116190 Ave neighs/atom = 58.095000 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 = 293.18062968871, Press = 0.99454133139791 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 121000 -8046.2289 -8046.2289 -8121.4153 -8121.4153 290.97937 290.97937 24063.678 24063.678 1597.411 1597.411 122000 -8042.0954 -8042.0954 -8117.0436 -8117.0436 290.05714 290.05714 24121.797 24121.797 -2348.9235 -2348.9235 Loop time of 97.4956 on 1 procs for 1000 steps with 2000 atoms Performance: 0.886 ns/day, 27.082 hours/ns, 10.257 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 | 97.004 | 97.004 | 97.004 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074269 | 0.074269 | 0.074269 | 0.0 | 0.08 Output | 0.00015936 | 0.00015936 | 0.00015936 | 0.0 | 0.00 Modify | 0.35999 | 0.35999 | 0.35999 | 0.0 | 0.37 Other | | 0.05704 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116230.0 ave 116230 max 116230 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116230 Ave neighs/atom = 58.115000 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 = 293.169768547251, Press = 0.953034835614432 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 122000 -8042.0954 -8042.0954 -8117.0436 -8117.0436 290.05714 290.05714 24121.797 24121.797 -2348.9235 -2348.9235 123000 -8044.3716 -8044.3716 -8120.5683 -8120.5683 294.88898 294.88898 24049.102 24049.102 2917.3016 2917.3016 Loop time of 97.2058 on 1 procs for 1000 steps with 2000 atoms Performance: 0.889 ns/day, 27.002 hours/ns, 10.287 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 | 96.711 | 96.711 | 96.711 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074762 | 0.074762 | 0.074762 | 0.0 | 0.08 Output | 0.00019176 | 0.00019176 | 0.00019176 | 0.0 | 0.00 Modify | 0.36254 | 0.36254 | 0.36254 | 0.0 | 0.37 Other | | 0.05698 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2949.00 ave 2949 max 2949 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116196.0 ave 116196 max 116196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116196 Ave neighs/atom = 58.098000 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 = 293.167664308417, Press = 0.668924654795568 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 123000 -8044.3716 -8044.3716 -8120.5683 -8120.5683 294.88898 294.88898 24049.102 24049.102 2917.3016 2917.3016 124000 -8042.2654 -8042.2654 -8119.9979 -8119.9979 300.8326 300.8326 24119.4 24119.4 -2292.5613 -2292.5613 Loop time of 96.7849 on 1 procs for 1000 steps with 2000 atoms Performance: 0.893 ns/day, 26.885 hours/ns, 10.332 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 | 96.297 | 96.297 | 96.297 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074354 | 0.074354 | 0.074354 | 0.0 | 0.08 Output | 0.00015645 | 0.00015645 | 0.00015645 | 0.0 | 0.00 Modify | 0.35664 | 0.35664 | 0.35664 | 0.0 | 0.37 Other | | 0.05647 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116234.0 ave 116234 max 116234 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116234 Ave neighs/atom = 58.117000 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 = 293.165464809146, Press = 1.26900411623357 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 124000 -8042.2654 -8042.2654 -8119.9979 -8119.9979 300.8326 300.8326 24119.4 24119.4 -2292.5613 -2292.5613 125000 -8044.859 -8044.859 -8117.8593 -8117.8593 282.51875 282.51875 24067.788 24067.788 1676.2604 1676.2604 Loop time of 98.0689 on 1 procs for 1000 steps with 2000 atoms Performance: 0.881 ns/day, 27.241 hours/ns, 10.197 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 | 97.569 | 97.569 | 97.569 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075234 | 0.075234 | 0.075234 | 0.0 | 0.08 Output | 0.0001556 | 0.0001556 | 0.0001556 | 0.0 | 0.00 Modify | 0.36727 | 0.36727 | 0.36727 | 0.0 | 0.37 Other | | 0.05684 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2947.00 ave 2947 max 2947 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116152.0 ave 116152 max 116152 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116152 Ave neighs/atom = 58.076000 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 = 293.185876904033, Press = 0.719598951151177 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 125000 -8044.859 -8044.859 -8117.8593 -8117.8593 282.51875 282.51875 24067.788 24067.788 1676.2604 1676.2604 126000 -8041.1483 -8041.1483 -8118.549 -8118.549 299.54877 299.54877 24107.179 24107.179 -1289.9864 -1289.9864 Loop time of 98.6852 on 1 procs for 1000 steps with 2000 atoms Performance: 0.876 ns/day, 27.413 hours/ns, 10.133 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 | 98.185 | 98.185 | 98.185 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.07537 | 0.07537 | 0.07537 | 0.0 | 0.08 Output | 0.00015429 | 0.00015429 | 0.00015429 | 0.0 | 0.00 Modify | 0.36768 | 0.36768 | 0.36768 | 0.0 | 0.37 Other | | 0.05677 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2941.00 ave 2941 max 2941 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116204.0 ave 116204 max 116204 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116204 Ave neighs/atom = 58.102000 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 = 293.186971398691, Press = 1.16466852292464 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 126000 -8041.1483 -8041.1483 -8118.549 -8118.549 299.54877 299.54877 24107.179 24107.179 -1289.9864 -1289.9864 127000 -8044.4776 -8044.4776 -8119.8059 -8119.8059 291.52862 291.52862 24077.923 24077.923 676.45435 676.45435 Loop time of 96.9608 on 1 procs for 1000 steps with 2000 atoms Performance: 0.891 ns/day, 26.934 hours/ns, 10.313 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 | 96.471 | 96.471 | 96.471 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.074823 | 0.074823 | 0.074823 | 0.0 | 0.08 Output | 0.00015782 | 0.00015782 | 0.00015782 | 0.0 | 0.00 Modify | 0.35783 | 0.35783 | 0.35783 | 0.0 | 0.37 Other | | 0.05659 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2942.00 ave 2942 max 2942 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116190.0 ave 116190 max 116190 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116190 Ave neighs/atom = 58.095000 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 = 293.195202441964, Press = 0.550038146612975 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 127000 -8044.4776 -8044.4776 -8119.8059 -8119.8059 291.52862 291.52862 24077.923 24077.923 676.45435 676.45435 128000 -8041.9588 -8041.9588 -8118.5374 -8118.5374 296.36715 296.36715 24096.456 24096.456 -573.10914 -573.10914 Loop time of 96.8764 on 1 procs for 1000 steps with 2000 atoms Performance: 0.892 ns/day, 26.910 hours/ns, 10.322 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 | 96.388 | 96.388 | 96.388 | 0.0 | 99.50 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.073875 | 0.073875 | 0.073875 | 0.0 | 0.08 Output | 0.00020123 | 0.00020123 | 0.00020123 | 0.0 | 0.00 Modify | 0.35797 | 0.35797 | 0.35797 | 0.0 | 0.37 Other | | 0.056 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2944.00 ave 2944 max 2944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116206.0 ave 116206 max 116206 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116206 Ave neighs/atom = 58.103000 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 = 293.206990542747, Press = 1.44921143823373 next a jump SELF top variable a loop 2000 run 1000 Neighbor list info ... update every 1 steps, delay 10 steps, check yes max neighbors/atom: 2000, page size: 100000 master list distance cutoff = 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 128000 -8041.9588 -8041.9588 -8118.5374 -8118.5374 296.36715 296.36715 24096.456 24096.456 -573.10914 -573.10914 129000 -8044.1491 -8044.1491 -8119.9156 -8119.9156 293.22441 293.22441 24099.72 24099.72 -836.2712 -836.2712 Loop time of 97.7347 on 1 procs for 1000 steps with 2000 atoms Performance: 0.884 ns/day, 27.149 hours/ns, 10.232 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 | 97.24 | 97.24 | 97.24 | 0.0 | 99.49 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.075364 | 0.075364 | 0.075364 | 0.0 | 0.08 Output | 0.00019179 | 0.00019179 | 0.00019179 | 0.0 | 0.00 Modify | 0.36169 | 0.36169 | 0.36169 | 0.0 | 0.37 Other | | 0.05712 | | | 0.06 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 2943.00 ave 2943 max 2943 min Histogram: 1 0 0 0 0 0 0 0 0 0 Neighs: 0.00000 ave 0 max 0 min Histogram: 1 0 0 0 0 0 0 0 0 0 FullNghs: 116174.0 ave 116174 max 116174 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 116174 Ave neighs/atom = 58.087000 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_T293.15.out" else "print 'not_converged' file output/vol_T293.15.out" print '${V}' file output/vol_T293.15.out 24086.3355757338 print "LAMMPS calculation completed" LAMMPS calculation completed quit 0