# 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 3.031088903546333*${_u_distance} variable latticeconst_converted equal 3.031088903546333*1 lattice bcc ${latticeconst_converted} lattice bcc 3.03108890354633 Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889 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 (30.310889 30.310889 30.310889) 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 (30.310889 30.310889 30.310889) create_atoms CPU = 0.004 seconds variable mass_converted equal 50.9415*${_u_mass} variable mass_converted equal 50.9415*1 kim_interactions V WARNING: 'kim_' has been renamed to 'kim '. Please update your input. kim interactions V #=== BEGIN kim interactions ================================== pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_001 pair_coeff * * V #=== END kim interactions ==================================== mass 1 ${mass_converted} mass 1 50.9415 # initial volume variable v equal vol # assign formula variable V0 equal ${v} # evaluate initial value variable V0 equal 27848.129123109 variable V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance}) variable V0_metal equal 27848.129123109/(${_u_distance}*${_u_distance}*${_u_distance}) variable V0_metal equal 27848.129123109/(1*${_u_distance}*${_u_distance}) variable V0_metal equal 27848.129123109/(1*1*${_u_distance}) variable V0_metal equal 27848.129123109/(1*1*1) variable V0_metal_times1000 equal ${V0_metal}*1000 variable V0_metal_times1000 equal 27848.129123109*1000 print "Initial system volume: ${V0_metal} Angstroms^3" Initial system volume: 27848.129123109 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_912978207512_001#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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 0 -10524.253 -10524.253 -10600 -10600 293.15 293.15 27848.129 27848.129 2905.3071 2905.3071 1000 -10441.898 -10441.898 -10524.384 -10524.384 319.22966 319.22966 28071.997 28071.997 -1746.692 -1746.692 Loop time of 169.185 on 1 procs for 1000 steps with 2000 atoms Performance: 0.511 ns/day, 46.996 hours/ns, 5.911 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 | 168.68 | 168.68 | 168.68 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098557 | 0.098557 | 0.098557 | 0.0 | 0.06 Output | 0.00025019 | 0.00025019 | 0.00025019 | 0.0 | 0.00 Modify | 0.34972 | 0.34972 | 0.34972 | 0.0 | 0.21 Other | | 0.06026 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 128000.0 ave 128000 max 128000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 128000 Ave neighs/atom = 64.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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 1000 -10441.898 -10441.898 -10524.384 -10524.384 319.22966 319.22966 28071.997 28071.997 -1746.692 -1746.692 2000 -10445.504 -10445.504 -10522.254 -10522.254 297.02913 297.02913 28054.604 28054.604 -712.02545 -712.02545 Loop time of 177.094 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.193 hours/ns, 5.647 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 | 176.57 | 176.57 | 176.57 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10044 | 0.10044 | 0.10044 | 0.0 | 0.06 Output | 0.00024885 | 0.00024885 | 0.00024885 | 0.0 | 0.00 Modify | 0.36159 | 0.36159 | 0.36159 | 0.0 | 0.20 Other | | 0.06165 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134178.0 ave 134178 max 134178 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134178 Ave neighs/atom = 67.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 = 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 2000 -10445.504 -10445.504 -10522.254 -10522.254 297.02913 297.02913 28054.604 28054.604 -712.02545 -712.02545 3000 -10444.915 -10444.915 -10520.059 -10520.059 290.81275 290.81275 28010.515 28010.515 1791.5446 1791.5446 Loop time of 180.199 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.055 hours/ns, 5.549 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 | 179.67 | 179.67 | 179.67 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10127 | 0.10127 | 0.10127 | 0.0 | 0.06 Output | 0.00018806 | 0.00018806 | 0.00018806 | 0.0 | 0.00 Modify | 0.36816 | 0.36816 | 0.36816 | 0.0 | 0.20 Other | | 0.06256 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134552.0 ave 134552 max 134552 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134552 Ave neighs/atom = 67.276000 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 3000 -10444.915 -10444.915 -10520.059 -10520.059 290.81275 290.81275 28010.515 28010.515 1791.5446 1791.5446 4000 -10444.654 -10444.654 -10517.275 -10517.275 281.04813 281.04813 28040.941 28040.941 192.57328 192.57328 Loop time of 181.306 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.363 hours/ns, 5.516 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 | 180.77 | 180.77 | 180.77 | 0.0 | 99.71 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10153 | 0.10153 | 0.10153 | 0.0 | 0.06 Output | 0.00018863 | 0.00018863 | 0.00018863 | 0.0 | 0.00 Modify | 0.36887 | 0.36887 | 0.36887 | 0.0 | 0.20 Other | | 0.06196 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135268.0 ave 135268 max 135268 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135268 Ave neighs/atom = 67.634000 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 4000 -10444.654 -10444.654 -10517.275 -10517.275 281.04813 281.04813 28040.941 28040.941 192.57328 192.57328 5000 -10443.647 -10443.647 -10520.943 -10520.943 299.14291 299.14291 28088.505 28088.505 -2260.2648 -2260.2648 Loop time of 177.608 on 1 procs for 1000 steps with 2000 atoms Performance: 0.486 ns/day, 49.336 hours/ns, 5.630 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 | 177.09 | 177.09 | 177.09 | 0.0 | 99.71 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099288 | 0.099288 | 0.099288 | 0.0 | 0.06 Output | 0.00015643 | 0.00015643 | 0.00015643 | 0.0 | 0.00 Modify | 0.35652 | 0.35652 | 0.35652 | 0.0 | 0.20 Other | | 0.06139 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135260.0 ave 135260 max 135260 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135260 Ave neighs/atom = 67.630000 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.811334487172, Press = -357.223561345095 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 5000 -10443.647 -10443.647 -10520.943 -10520.943 299.14291 299.14291 28088.505 28088.505 -2260.2648 -2260.2648 6000 -10443.558 -10443.558 -10519.883 -10519.883 295.38841 295.38841 27980.476 27980.476 3507.9573 3507.9573 Loop time of 179.469 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.852 hours/ns, 5.572 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 | 178.92 | 178.92 | 178.92 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10166 | 0.10166 | 0.10166 | 0.0 | 0.06 Output | 0.00018845 | 0.00018845 | 0.00018845 | 0.0 | 0.00 Modify | 0.38323 | 0.38323 | 0.38323 | 0.0 | 0.21 Other | | 0.06229 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134344.0 ave 134344 max 134344 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134344 Ave neighs/atom = 67.172000 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.625270143878, Press = -13.3490647298068 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 6000 -10443.558 -10443.558 -10519.883 -10519.883 295.38841 295.38841 27980.476 27980.476 3507.9573 3507.9573 7000 -10444.393 -10444.393 -10518.323 -10518.323 286.1155 286.1155 28044.034 28044.034 -70.343898 -70.343898 Loop time of 180.292 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.081 hours/ns, 5.547 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 | 179.75 | 179.75 | 179.75 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.1012 | 0.1012 | 0.1012 | 0.0 | 0.06 Output | 0.00019954 | 0.00019954 | 0.00019954 | 0.0 | 0.00 Modify | 0.38343 | 0.38343 | 0.38343 | 0.0 | 0.21 Other | | 0.06164 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135340.0 ave 135340 max 135340 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135340 Ave neighs/atom = 67.670000 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 = 291.785167444732, Press = 31.8755659568526 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 7000 -10444.393 -10444.393 -10518.323 -10518.323 286.1155 286.1155 28044.034 28044.034 -70.343898 -70.343898 8000 -10444.068 -10444.068 -10518.844 -10518.844 289.39337 289.39337 28061.954 28061.954 -1031.1159 -1031.1159 Loop time of 181.283 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.356 hours/ns, 5.516 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 | 180.73 | 180.73 | 180.73 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10155 | 0.10155 | 0.10155 | 0.0 | 0.06 Output | 0.00020476 | 0.00020476 | 0.00020476 | 0.0 | 0.00 Modify | 0.38611 | 0.38611 | 0.38611 | 0.0 | 0.21 Other | | 0.06226 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135220.0 ave 135220 max 135220 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135220 Ave neighs/atom = 67.610000 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.449502149359, Press = -3.27347487046044 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 8000 -10444.068 -10444.068 -10518.844 -10518.844 289.39337 289.39337 28061.954 28061.954 -1031.1159 -1031.1159 9000 -10445.215 -10445.215 -10518.575 -10518.575 283.91054 283.91054 28005.631 28005.631 1896.4334 1896.4334 Loop time of 182.257 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.627 hours/ns, 5.487 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 | 181.7 | 181.7 | 181.7 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10226 | 0.10226 | 0.10226 | 0.0 | 0.06 Output | 0.00015423 | 0.00015423 | 0.00015423 | 0.0 | 0.00 Modify | 0.39189 | 0.39189 | 0.39189 | 0.0 | 0.22 Other | | 0.06236 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134816.0 ave 134816 max 134816 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134816 Ave neighs/atom = 67.408000 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.447026848868, Press = 4.91474401942027 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 9000 -10445.215 -10445.215 -10518.575 -10518.575 283.91054 283.91054 28005.631 28005.631 1896.4334 1896.4334 10000 -10444.038 -10444.038 -10518.808 -10518.808 289.36818 289.36818 28053.845 28053.845 -706.866 -706.866 Loop time of 181.011 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.281 hours/ns, 5.525 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 | 180.46 | 180.46 | 180.46 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10114 | 0.10114 | 0.10114 | 0.0 | 0.06 Output | 0.00015924 | 0.00015924 | 0.00015924 | 0.0 | 0.00 Modify | 0.384 | 0.384 | 0.384 | 0.0 | 0.21 Other | | 0.06124 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135396.0 ave 135396 max 135396 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135396 Ave neighs/atom = 67.698000 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.142324855642, Press = 14.7097610883905 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 10000 -10444.038 -10444.038 -10518.808 -10518.808 289.36818 289.36818 28053.845 28053.845 -706.866 -706.866 11000 -10445.888 -10445.888 -10523.782 -10523.782 301.45915 301.45915 28079.498 28079.498 -2308.2741 -2308.2741 Loop time of 182.985 on 1 procs for 1000 steps with 2000 atoms Performance: 0.472 ns/day, 50.829 hours/ns, 5.465 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 | 182.42 | 182.42 | 182.42 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10456 | 0.10456 | 0.10456 | 0.0 | 0.06 Output | 0.00015638 | 0.00015638 | 0.00015638 | 0.0 | 0.00 Modify | 0.4001 | 0.4001 | 0.4001 | 0.0 | 0.22 Other | | 0.0629 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135000.0 ave 135000 max 135000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135000 Ave neighs/atom = 67.500000 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.317026486114, Press = -8.14702138436728 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 11000 -10445.888 -10445.888 -10523.782 -10523.782 301.45915 301.45915 28079.498 28079.498 -2308.2741 -2308.2741 12000 -10444.102 -10444.102 -10521.713 -10521.713 300.36274 300.36274 27991.592 27991.592 2546.5315 2546.5315 Loop time of 181.739 on 1 procs for 1000 steps with 2000 atoms Performance: 0.475 ns/day, 50.483 hours/ns, 5.502 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 181.18 | 181.18 | 181.18 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10269 | 0.10269 | 0.10269 | 0.0 | 0.06 Output | 0.00015364 | 0.00015364 | 0.00015364 | 0.0 | 0.00 Modify | 0.39216 | 0.39216 | 0.39216 | 0.0 | 0.22 Other | | 0.06258 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134440.0 ave 134440 max 134440 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134440 Ave neighs/atom = 67.220000 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.174930294946, Press = 2.50568664745801 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 12000 -10444.102 -10444.102 -10521.713 -10521.713 300.36274 300.36274 27991.592 27991.592 2546.5315 2546.5315 13000 -10445.412 -10445.412 -10519.738 -10519.738 287.64742 287.64742 28051.289 28051.289 -374.52356 -374.52356 Loop time of 181.235 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.343 hours/ns, 5.518 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 | 180.68 | 180.68 | 180.68 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10164 | 0.10164 | 0.10164 | 0.0 | 0.06 Output | 0.00022172 | 0.00022172 | 0.00022172 | 0.0 | 0.00 Modify | 0.391 | 0.391 | 0.391 | 0.0 | 0.22 Other | | 0.06242 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135274.0 ave 135274 max 135274 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135274 Ave neighs/atom = 67.637000 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 = 291.984426646955, Press = 7.18949675586921 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 13000 -10445.412 -10445.412 -10519.738 -10519.738 287.64742 287.64742 28051.289 28051.289 -374.52356 -374.52356 14000 -10445.681 -10445.681 -10523.122 -10523.122 299.70788 299.70788 28054.836 28054.836 -838.22932 -838.22932 Loop time of 182.409 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.669 hours/ns, 5.482 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 | 181.85 | 181.85 | 181.85 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10195 | 0.10195 | 0.10195 | 0.0 | 0.06 Output | 0.00015479 | 0.00015479 | 0.00015479 | 0.0 | 0.00 Modify | 0.38929 | 0.38929 | 0.38929 | 0.0 | 0.21 Other | | 0.06224 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134786.0 ave 134786 max 134786 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134786 Ave neighs/atom = 67.393000 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.046208520068, Press = 0.727381104619603 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 14000 -10445.681 -10445.681 -10523.122 -10523.122 299.70788 299.70788 28054.836 28054.836 -838.22932 -838.22932 15000 -10442.001 -10442.001 -10518.761 -10518.761 297.06797 297.06797 28027.946 28027.946 1032.4998 1032.4998 Loop time of 181.187 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.330 hours/ns, 5.519 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 | 180.64 | 180.64 | 180.64 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10097 | 0.10097 | 0.10097 | 0.0 | 0.06 Output | 0.00039421 | 0.00039421 | 0.00039421 | 0.0 | 0.00 Modify | 0.38479 | 0.38479 | 0.38479 | 0.0 | 0.21 Other | | 0.0621 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134314.0 ave 134314 max 134314 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134314 Ave neighs/atom = 67.157000 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.106830915851, Press = 2.27201619825322 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 15000 -10442.001 -10442.001 -10518.761 -10518.761 297.06797 297.06797 28027.946 28027.946 1032.4998 1032.4998 16000 -10445.779 -10445.779 -10522.298 -10522.298 296.13401 296.13401 28046.335 28046.335 -313.45634 -313.45634 Loop time of 180.019 on 1 procs for 1000 steps with 2000 atoms Performance: 0.480 ns/day, 50.005 hours/ns, 5.555 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 | 179.47 | 179.47 | 179.47 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10109 | 0.10109 | 0.10109 | 0.0 | 0.06 Output | 0.00024321 | 0.00024321 | 0.00024321 | 0.0 | 0.00 Modify | 0.38304 | 0.38304 | 0.38304 | 0.0 | 0.21 Other | | 0.06172 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135158.0 ave 135158 max 135158 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135158 Ave neighs/atom = 67.579000 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.114083422807, Press = 7.51217948131607 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 16000 -10445.779 -10445.779 -10522.298 -10522.298 296.13401 296.13401 28046.335 28046.335 -313.45634 -313.45634 17000 -10443.312 -10443.312 -10518.671 -10518.671 291.64642 291.64642 28088.557 28088.557 -2453.681 -2453.681 Loop time of 181.047 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.291 hours/ns, 5.523 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 | 180.49 | 180.49 | 180.49 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10181 | 0.10181 | 0.10181 | 0.0 | 0.06 Output | 0.00016209 | 0.00016209 | 0.00016209 | 0.0 | 0.00 Modify | 0.38851 | 0.38851 | 0.38851 | 0.0 | 0.21 Other | | 0.06206 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134786.0 ave 134786 max 134786 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134786 Ave neighs/atom = 67.393000 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.063929796766, Press = -2.41602854912015 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 17000 -10443.312 -10443.312 -10518.671 -10518.671 291.64642 291.64642 28088.557 28088.557 -2453.681 -2453.681 18000 -10443.305 -10443.305 -10518.219 -10518.219 289.92459 289.92459 28003.774 28003.774 2140.834 2140.834 Loop time of 181.804 on 1 procs for 1000 steps with 2000 atoms Performance: 0.475 ns/day, 50.501 hours/ns, 5.500 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 | 181.25 | 181.25 | 181.25 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10314 | 0.10314 | 0.10314 | 0.0 | 0.06 Output | 0.00015202 | 0.00015202 | 0.00015202 | 0.0 | 0.00 Modify | 0.39243 | 0.39243 | 0.39243 | 0.0 | 0.22 Other | | 0.06207 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134552.0 ave 134552 max 134552 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134552 Ave neighs/atom = 67.276000 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.013528258351, Press = 0.609188757445904 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 18000 -10443.305 -10443.305 -10518.219 -10518.219 289.92459 289.92459 28003.774 28003.774 2140.834 2140.834 19000 -10445.361 -10445.361 -10521.933 -10521.933 296.33925 296.33925 28042.712 28042.712 -169.75689 -169.75689 Loop time of 182.141 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.595 hours/ns, 5.490 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 | 181.59 | 181.59 | 181.59 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10198 | 0.10198 | 0.10198 | 0.0 | 0.06 Output | 0.00015131 | 0.00015131 | 0.00015131 | 0.0 | 0.00 Modify | 0.38409 | 0.38409 | 0.38409 | 0.0 | 0.21 Other | | 0.06163 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135242.0 ave 135242 max 135242 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135242 Ave neighs/atom = 67.621000 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.159304980965, Press = 4.32351559972396 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 19000 -10445.361 -10445.361 -10521.933 -10521.933 296.33925 296.33925 28042.712 28042.712 -169.75689 -169.75689 20000 -10442.812 -10442.812 -10520.31 -10520.31 299.92389 299.92389 28064.914 28064.914 -1211.5281 -1211.5281 Loop time of 181.151 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.320 hours/ns, 5.520 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 | 180.6 | 180.6 | 180.6 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10263 | 0.10263 | 0.10263 | 0.0 | 0.06 Output | 0.00020022 | 0.00020022 | 0.00020022 | 0.0 | 0.00 Modify | 0.38869 | 0.38869 | 0.38869 | 0.0 | 0.21 Other | | 0.06173 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134750.0 ave 134750 max 134750 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134750 Ave neighs/atom = 67.375000 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.304515270434, Press = 0.912725039768205 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 20000 -10442.812 -10442.812 -10520.31 -10520.31 299.92389 299.92389 28064.914 28064.914 -1211.5281 -1211.5281 21000 -10448.6 -10448.6 -10522.1 -10522.1 284.45463 284.45463 28031.574 28031.574 284.35386 284.35386 Loop time of 180.19 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.053 hours/ns, 5.550 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 | 179.64 | 179.64 | 179.64 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10127 | 0.10127 | 0.10127 | 0.0 | 0.06 Output | 0.00015451 | 0.00015451 | 0.00015451 | 0.0 | 0.00 Modify | 0.38502 | 0.38502 | 0.38502 | 0.0 | 0.21 Other | | 0.06197 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134716.0 ave 134716 max 134716 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134716 Ave neighs/atom = 67.358000 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.287924920127, Press = 0.983031261940285 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 21000 -10448.6 -10448.6 -10522.1 -10522.1 284.45463 284.45463 28031.574 28031.574 284.35386 284.35386 22000 -10444.07 -10444.07 -10521.214 -10521.214 298.55713 298.55713 28040.419 28040.419 38.807177 38.807177 Loop time of 178.037 on 1 procs for 1000 steps with 2000 atoms Performance: 0.485 ns/day, 49.455 hours/ns, 5.617 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 | 177.5 | 177.5 | 177.5 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10014 | 0.10014 | 0.10014 | 0.0 | 0.06 Output | 0.00016205 | 0.00016205 | 0.00016205 | 0.0 | 0.00 Modify | 0.37688 | 0.37688 | 0.37688 | 0.0 | 0.21 Other | | 0.0613 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134884.0 ave 134884 max 134884 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134884 Ave neighs/atom = 67.442000 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.22222119374, Press = 1.31729828983212 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 22000 -10444.07 -10444.07 -10521.214 -10521.214 298.55713 298.55713 28040.419 28040.419 38.807177 38.807177 23000 -10444.808 -10444.808 -10519.417 -10519.417 288.74252 288.74252 28046.712 28046.712 -174.57973 -174.57973 Loop time of 185.846 on 1 procs for 1000 steps with 2000 atoms Performance: 0.465 ns/day, 51.624 hours/ns, 5.381 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 | 185.27 | 185.27 | 185.27 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10439 | 0.10439 | 0.10439 | 0.0 | 0.06 Output | 0.00015472 | 0.00015472 | 0.00015472 | 0.0 | 0.00 Modify | 0.40629 | 0.40629 | 0.40629 | 0.0 | 0.22 Other | | 0.06395 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134752.0 ave 134752 max 134752 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134752 Ave neighs/atom = 67.376000 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.24737480619, Press = 1.23983299718397 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 23000 -10444.808 -10444.808 -10519.417 -10519.417 288.74252 288.74252 28046.712 28046.712 -174.57973 -174.57973 24000 -10441.025 -10441.025 -10518.917 -10518.917 301.44957 301.44957 28052.009 28052.009 -263.78852 -263.78852 Loop time of 182.341 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.650 hours/ns, 5.484 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 | 181.78 | 181.78 | 181.78 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10293 | 0.10293 | 0.10293 | 0.0 | 0.06 Output | 0.00018881 | 0.00018881 | 0.00018881 | 0.0 | 0.00 Modify | 0.39194 | 0.39194 | 0.39194 | 0.0 | 0.21 Other | | 0.06274 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134872.0 ave 134872 max 134872 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134872 Ave neighs/atom = 67.436000 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.423572020345, Press = 0.450507379541569 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 24000 -10441.025 -10441.025 -10518.917 -10518.917 301.44957 301.44957 28052.009 28052.009 -263.78852 -263.78852 25000 -10445.633 -10445.633 -10521.212 -10521.212 292.49636 292.49636 28012.517 28012.517 1474.9442 1474.9442 Loop time of 179.297 on 1 procs for 1000 steps with 2000 atoms Performance: 0.482 ns/day, 49.805 hours/ns, 5.577 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 | 178.75 | 178.75 | 178.75 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10079 | 0.10079 | 0.10079 | 0.0 | 0.06 Output | 0.00015765 | 0.00015765 | 0.00015765 | 0.0 | 0.00 Modify | 0.38202 | 0.38202 | 0.38202 | 0.0 | 0.21 Other | | 0.06179 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134820.0 ave 134820 max 134820 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134820 Ave neighs/atom = 67.410000 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.56584291915, Press = 1.07916669018423 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 25000 -10445.633 -10445.633 -10521.212 -10521.212 292.49636 292.49636 28012.517 28012.517 1474.9442 1474.9442 26000 -10446.806 -10446.806 -10521.676 -10521.676 289.75263 289.75263 28062.175 28062.175 -1282.0846 -1282.0846 Loop time of 180.633 on 1 procs for 1000 steps with 2000 atoms Performance: 0.478 ns/day, 50.176 hours/ns, 5.536 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 | 180.08 | 180.08 | 180.08 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.1021 | 0.1021 | 0.1021 | 0.0 | 0.06 Output | 0.00015593 | 0.00015593 | 0.00015593 | 0.0 | 0.00 Modify | 0.3881 | 0.3881 | 0.3881 | 0.0 | 0.21 Other | | 0.0615 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134920.0 ave 134920 max 134920 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134920 Ave neighs/atom = 67.460000 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.635679347006, Press = 2.81758880219023 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 26000 -10446.806 -10446.806 -10521.676 -10521.676 289.75263 289.75263 28062.175 28062.175 -1282.0846 -1282.0846 27000 -10444.558 -10444.558 -10520.82 -10520.82 295.14542 295.14542 28050.7 28050.7 -529.1019 -529.1019 Loop time of 182.174 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.604 hours/ns, 5.489 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 | 181.61 | 181.61 | 181.61 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10266 | 0.10266 | 0.10266 | 0.0 | 0.06 Output | 0.00020295 | 0.00020295 | 0.00020295 | 0.0 | 0.00 Modify | 0.39482 | 0.39482 | 0.39482 | 0.0 | 0.22 Other | | 0.06237 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134596.0 ave 134596 max 134596 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134596 Ave neighs/atom = 67.298000 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.546732515072, Press = -2.01525048098109 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 27000 -10444.558 -10444.558 -10520.82 -10520.82 295.14542 295.14542 28050.7 28050.7 -529.1019 -529.1019 28000 -10445.706 -10445.706 -10522.136 -10522.136 295.79139 295.79139 27991.107 27991.107 2679.4266 2679.4266 Loop time of 178.599 on 1 procs for 1000 steps with 2000 atoms Performance: 0.484 ns/day, 49.611 hours/ns, 5.599 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 | 178.06 | 178.06 | 178.06 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10037 | 0.10037 | 0.10037 | 0.0 | 0.06 Output | 0.00015459 | 0.00015459 | 0.00015459 | 0.0 | 0.00 Modify | 0.38108 | 0.38108 | 0.38108 | 0.0 | 0.21 Other | | 0.06183 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134714.0 ave 134714 max 134714 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134714 Ave neighs/atom = 67.357000 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.597533026125, Press = 1.74859239212113 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 28000 -10445.706 -10445.706 -10522.136 -10522.136 295.79139 295.79139 27991.107 27991.107 2679.4266 2679.4266 29000 -10442.048 -10442.048 -10521.002 -10521.002 305.55742 305.55742 28074.571 28074.571 -1744.2163 -1744.2163 Loop time of 182.238 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.622 hours/ns, 5.487 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 | 181.68 | 181.68 | 181.68 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10159 | 0.10159 | 0.10159 | 0.0 | 0.06 Output | 0.00015109 | 0.00015109 | 0.00015109 | 0.0 | 0.00 Modify | 0.39159 | 0.39159 | 0.39159 | 0.0 | 0.21 Other | | 0.06228 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135042.0 ave 135042 max 135042 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135042 Ave neighs/atom = 67.521000 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.627498735716, Press = 2.22007725091554 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 29000 -10442.048 -10442.048 -10521.002 -10521.002 305.55742 305.55742 28074.571 28074.571 -1744.2163 -1744.2163 30000 -10444.616 -10444.616 -10521.216 -10521.216 296.45181 296.45181 28045.487 28045.487 -369.80135 -369.80135 Loop time of 180.613 on 1 procs for 1000 steps with 2000 atoms Performance: 0.478 ns/day, 50.170 hours/ns, 5.537 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 | 180.06 | 180.06 | 180.06 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10132 | 0.10132 | 0.10132 | 0.0 | 0.06 Output | 0.00015295 | 0.00015295 | 0.00015295 | 0.0 | 0.00 Modify | 0.38531 | 0.38531 | 0.38531 | 0.0 | 0.21 Other | | 0.06191 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134558.0 ave 134558 max 134558 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134558 Ave neighs/atom = 67.279000 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.660244666029, Press = -0.689969540185267 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 30000 -10444.616 -10444.616 -10521.216 -10521.216 296.45181 296.45181 28045.487 28045.487 -369.80135 -369.80135 31000 -10447.761 -10447.761 -10524.137 -10524.137 295.58402 295.58402 28026.571 28026.571 486.15387 486.15387 Loop time of 180.634 on 1 procs for 1000 steps with 2000 atoms Performance: 0.478 ns/day, 50.176 hours/ns, 5.536 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 | 180.07 | 180.07 | 180.07 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10284 | 0.10284 | 0.10284 | 0.0 | 0.06 Output | 0.00018926 | 0.00018926 | 0.00018926 | 0.0 | 0.00 Modify | 0.39537 | 0.39537 | 0.39537 | 0.0 | 0.22 Other | | 0.06293 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134760.0 ave 134760 max 134760 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134760 Ave neighs/atom = 67.380000 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.595193376649, Press = 1.31765473523878 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 31000 -10447.761 -10447.761 -10524.137 -10524.137 295.58402 295.58402 28026.571 28026.571 486.15387 486.15387 32000 -10442.955 -10442.955 -10518.592 -10518.592 292.722 292.722 28063.133 28063.133 -952.81865 -952.81865 Loop time of 182.276 on 1 procs for 1000 steps with 2000 atoms Performance: 0.474 ns/day, 50.632 hours/ns, 5.486 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 | 181.71 | 181.71 | 181.71 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.103 | 0.103 | 0.103 | 0.0 | 0.06 Output | 0.00015729 | 0.00015729 | 0.00015729 | 0.0 | 0.00 Modify | 0.39527 | 0.39527 | 0.39527 | 0.0 | 0.22 Other | | 0.06296 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134488.0 ave 134488 max 134488 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134488 Ave neighs/atom = 67.244000 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.569322380931, Press = 0.904983822686904 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 32000 -10442.955 -10442.955 -10518.592 -10518.592 292.722 292.722 28063.133 28063.133 -952.81865 -952.81865 33000 -10449.81 -10449.81 -10523.321 -10523.321 284.49699 284.49699 28015.424 28015.424 1148.9163 1148.9163 Loop time of 181.089 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.302 hours/ns, 5.522 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 180.54 | 180.54 | 180.54 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10225 | 0.10225 | 0.10225 | 0.0 | 0.06 Output | 0.00015926 | 0.00015926 | 0.00015926 | 0.0 | 0.00 Modify | 0.38657 | 0.38657 | 0.38657 | 0.0 | 0.21 Other | | 0.06216 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134702.0 ave 134702 max 134702 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134702 Ave neighs/atom = 67.351000 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.522453444978, Press = -0.850047600049958 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 33000 -10449.81 -10449.81 -10523.321 -10523.321 284.49699 284.49699 28015.424 28015.424 1148.9163 1148.9163 34000 -10443.218 -10443.218 -10519.089 -10519.089 293.62882 293.62882 28007.022 28007.022 1852.9105 1852.9105 Loop time of 179.1 on 1 procs for 1000 steps with 2000 atoms Performance: 0.482 ns/day, 49.750 hours/ns, 5.583 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 | 178.55 | 178.55 | 178.55 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10038 | 0.10038 | 0.10038 | 0.0 | 0.06 Output | 0.000203 | 0.000203 | 0.000203 | 0.0 | 0.00 Modify | 0.38336 | 0.38336 | 0.38336 | 0.0 | 0.21 Other | | 0.06198 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134776.0 ave 134776 max 134776 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134776 Ave neighs/atom = 67.388000 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.50583248295, Press = 3.11419317778098 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 34000 -10443.218 -10443.218 -10519.089 -10519.089 293.62882 293.62882 28007.022 28007.022 1852.9105 1852.9105 35000 -10443.11 -10443.11 -10519.943 -10519.943 297.35309 297.35309 28087.799 28087.799 -2422.1651 -2422.1651 Loop time of 181.248 on 1 procs for 1000 steps with 2000 atoms Performance: 0.477 ns/day, 50.347 hours/ns, 5.517 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 | 180.7 | 180.7 | 180.7 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10179 | 0.10179 | 0.10179 | 0.0 | 0.06 Output | 0.00015581 | 0.00015581 | 0.00015581 | 0.0 | 0.00 Modify | 0.38526 | 0.38526 | 0.38526 | 0.0 | 0.21 Other | | 0.06254 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135408.0 ave 135408 max 135408 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135408 Ave neighs/atom = 67.704000 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.528933719408, Press = 0.786057711122415 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 35000 -10443.11 -10443.11 -10519.943 -10519.943 297.35309 297.35309 28087.799 28087.799 -2422.1651 -2422.1651 36000 -10444.653 -10444.653 -10520.862 -10520.862 294.93677 294.93677 28031.08 28031.08 572.8345 572.8345 Loop time of 178.469 on 1 procs for 1000 steps with 2000 atoms Performance: 0.484 ns/day, 49.575 hours/ns, 5.603 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 | 177.93 | 177.93 | 177.93 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10028 | 0.10028 | 0.10028 | 0.0 | 0.06 Output | 0.00018908 | 0.00018908 | 0.00018908 | 0.0 | 0.00 Modify | 0.37895 | 0.37895 | 0.37895 | 0.0 | 0.21 Other | | 0.0611 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134566.0 ave 134566 max 134566 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134566 Ave neighs/atom = 67.283000 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.580562438361, Press = -0.43476097535316 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 36000 -10444.653 -10444.653 -10520.862 -10520.862 294.93677 294.93677 28031.08 28031.08 572.8345 572.8345 37000 -10443.859 -10443.859 -10521.504 -10521.504 300.49652 300.49652 28039.942 28039.942 165.30524 165.30524 Loop time of 179.6 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.889 hours/ns, 5.568 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 | 179.06 | 179.06 | 179.06 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10011 | 0.10011 | 0.10011 | 0.0 | 0.06 Output | 0.00015644 | 0.00015644 | 0.00015644 | 0.0 | 0.00 Modify | 0.38143 | 0.38143 | 0.38143 | 0.0 | 0.21 Other | | 0.06202 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134964.0 ave 134964 max 134964 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134964 Ave neighs/atom = 67.482000 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.587247976846, Press = 1.3349171808405 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 37000 -10443.859 -10443.859 -10521.504 -10521.504 300.49652 300.49652 28039.942 28039.942 165.30524 165.30524 38000 -10445.185 -10445.185 -10520.745 -10520.745 292.42612 292.42612 28048.258 28048.258 -557.14864 -557.14864 Loop time of 180.305 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.085 hours/ns, 5.546 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 | 179.75 | 179.75 | 179.75 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.1017 | 0.1017 | 0.1017 | 0.0 | 0.06 Output | 0.0001975 | 0.0001975 | 0.0001975 | 0.0 | 0.00 Modify | 0.38637 | 0.38637 | 0.38637 | 0.0 | 0.21 Other | | 0.06277 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134788.0 ave 134788 max 134788 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134788 Ave neighs/atom = 67.394000 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.574823224041, Press = 0.296511663565674 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 38000 -10445.185 -10445.185 -10520.745 -10520.745 292.42612 292.42612 28048.258 28048.258 -557.14864 -557.14864 39000 -10443.968 -10443.968 -10520.599 -10520.599 296.57223 296.57223 28032.327 28032.327 343.10656 343.10656 Loop time of 178.852 on 1 procs for 1000 steps with 2000 atoms Performance: 0.483 ns/day, 49.681 hours/ns, 5.591 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 | 178.3 | 178.3 | 178.3 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10147 | 0.10147 | 0.10147 | 0.0 | 0.06 Output | 0.0001954 | 0.0001954 | 0.0001954 | 0.0 | 0.00 Modify | 0.38302 | 0.38302 | 0.38302 | 0.0 | 0.21 Other | | 0.06205 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134888.0 ave 134888 max 134888 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134888 Ave neighs/atom = 67.444000 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.586993508518, Press = 0.236823895835779 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 39000 -10443.968 -10443.968 -10520.599 -10520.599 296.57223 296.57223 28032.327 28032.327 343.10656 343.10656 40000 -10446.883 -10446.883 -10521.758 -10521.758 289.77492 289.77492 28037.574 28037.574 -71.213003 -71.213003 Loop time of 178.923 on 1 procs for 1000 steps with 2000 atoms Performance: 0.483 ns/day, 49.701 hours/ns, 5.589 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 | 178.38 | 178.38 | 178.38 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10093 | 0.10093 | 0.10093 | 0.0 | 0.06 Output | 0.00026722 | 0.00026722 | 0.00026722 | 0.0 | 0.00 Modify | 0.3837 | 0.3837 | 0.3837 | 0.0 | 0.21 Other | | 0.06177 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135178.0 ave 135178 max 135178 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135178 Ave neighs/atom = 67.589000 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.544968299598, Press = 1.07898910949766 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 40000 -10446.883 -10446.883 -10521.758 -10521.758 289.77492 289.77492 28037.574 28037.574 -71.213003 -71.213003 41000 -10443.042 -10443.042 -10518.932 -10518.932 293.69917 293.69917 28074.06 28074.06 -1729.6252 -1729.6252 Loop time of 175.598 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.777 hours/ns, 5.695 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 | 175.07 | 175.07 | 175.07 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099105 | 0.099105 | 0.099105 | 0.0 | 0.06 Output | 0.00056261 | 0.00056261 | 0.00056261 | 0.0 | 0.00 Modify | 0.37167 | 0.37167 | 0.37167 | 0.0 | 0.21 Other | | 0.06158 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134926.0 ave 134926 max 134926 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134926 Ave neighs/atom = 67.463000 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.571876798358, Press = -0.451801362308293 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 41000 -10443.042 -10443.042 -10518.932 -10518.932 293.69917 293.69917 28074.06 28074.06 -1729.6252 -1729.6252 42000 -10443.769 -10443.769 -10521.132 -10521.132 299.40249 299.40249 27989.93 27989.93 2737.3839 2737.3839 Loop time of 178.164 on 1 procs for 1000 steps with 2000 atoms Performance: 0.485 ns/day, 49.490 hours/ns, 5.613 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 | 177.62 | 177.62 | 177.62 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10209 | 0.10209 | 0.10209 | 0.0 | 0.06 Output | 0.00015582 | 0.00015582 | 0.00015582 | 0.0 | 0.00 Modify | 0.38085 | 0.38085 | 0.38085 | 0.0 | 0.21 Other | | 0.06212 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134708.0 ave 134708 max 134708 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134708 Ave neighs/atom = 67.354000 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.618752001924, Press = -0.461886907659643 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 42000 -10443.769 -10443.769 -10521.132 -10521.132 299.40249 299.40249 27989.93 27989.93 2737.3839 2737.3839 43000 -10441.778 -10441.778 -10518.924 -10518.924 298.5631 298.5631 28041.571 28041.571 200.4876 200.4876 Loop time of 179.478 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.855 hours/ns, 5.572 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 | 178.93 | 178.93 | 178.93 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10213 | 0.10213 | 0.10213 | 0.0 | 0.06 Output | 0.00019097 | 0.00019097 | 0.00019097 | 0.0 | 0.00 Modify | 0.38478 | 0.38478 | 0.38478 | 0.0 | 0.21 Other | | 0.06212 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135196.0 ave 135196 max 135196 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135196 Ave neighs/atom = 67.598000 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.724712403898, Press = 2.18800139630393 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 43000 -10441.778 -10441.778 -10518.924 -10518.924 298.5631 298.5631 28041.571 28041.571 200.4876 200.4876 44000 -10445.116 -10445.116 -10520.532 -10520.532 291.86837 291.86837 28069.661 28069.661 -1468.5241 -1468.5241 Loop time of 181.58 on 1 procs for 1000 steps with 2000 atoms Performance: 0.476 ns/day, 50.439 hours/ns, 5.507 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 | 181.02 | 181.02 | 181.02 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10296 | 0.10296 | 0.10296 | 0.0 | 0.06 Output | 0.0001531 | 0.0001531 | 0.0001531 | 0.0 | 0.00 Modify | 0.39119 | 0.39119 | 0.39119 | 0.0 | 0.22 Other | | 0.06276 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135124.0 ave 135124 max 135124 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135124 Ave neighs/atom = 67.562000 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.757180206653, Press = -0.306682716872256 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 44000 -10445.116 -10445.116 -10520.532 -10520.532 291.86837 291.86837 28069.661 28069.661 -1468.5241 -1468.5241 45000 -10441.254 -10441.254 -10517.887 -10517.887 296.57885 296.57885 28017.347 28017.347 1635.5041 1635.5041 Loop time of 179.523 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.867 hours/ns, 5.570 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 | 178.97 | 178.97 | 178.97 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10171 | 0.10171 | 0.10171 | 0.0 | 0.06 Output | 0.0002144 | 0.0002144 | 0.0002144 | 0.0 | 0.00 Modify | 0.39112 | 0.39112 | 0.39112 | 0.0 | 0.22 Other | | 0.06306 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134620.0 ave 134620 max 134620 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134620 Ave neighs/atom = 67.310000 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.829874884901, Press = 0.0384860254649054 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 45000 -10441.254 -10441.254 -10517.887 -10517.887 296.57885 296.57885 28017.347 28017.347 1635.5041 1635.5041 46000 -10444.381 -10444.381 -10519.103 -10519.103 289.18194 289.18194 28045.325 28045.325 -190.1782 -190.1782 Loop time of 178.54 on 1 procs for 1000 steps with 2000 atoms Performance: 0.484 ns/day, 49.594 hours/ns, 5.601 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 | 178 | 178 | 178 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10088 | 0.10088 | 0.10088 | 0.0 | 0.06 Output | 0.0001566 | 0.0001566 | 0.0001566 | 0.0 | 0.00 Modify | 0.3818 | 0.3818 | 0.3818 | 0.0 | 0.21 Other | | 0.06159 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135244.0 ave 135244 max 135244 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135244 Ave neighs/atom = 67.622000 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.818772189601, Press = 1.01646926266123 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 46000 -10444.381 -10444.381 -10519.103 -10519.103 289.18194 289.18194 28045.325 28045.325 -190.1782 -190.1782 47000 -10448.607 -10448.607 -10521.811 -10521.811 283.30746 283.30746 28039.543 28039.543 -336.40723 -336.40723 Loop time of 179.959 on 1 procs for 1000 steps with 2000 atoms Performance: 0.480 ns/day, 49.989 hours/ns, 5.557 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 | 179.41 | 179.41 | 179.41 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10186 | 0.10186 | 0.10186 | 0.0 | 0.06 Output | 0.00015685 | 0.00015685 | 0.00015685 | 0.0 | 0.00 Modify | 0.38826 | 0.38826 | 0.38826 | 0.0 | 0.22 Other | | 0.06226 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134768.0 ave 134768 max 134768 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134768 Ave neighs/atom = 67.384000 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.791895016374, Press = 0.197670957084162 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 47000 -10448.607 -10448.607 -10521.811 -10521.811 283.30746 283.30746 28039.543 28039.543 -336.40723 -336.40723 48000 -10443.69 -10443.69 -10520.201 -10520.201 296.10462 296.10462 28031.351 28031.351 556.32534 556.32534 Loop time of 177.81 on 1 procs for 1000 steps with 2000 atoms Performance: 0.486 ns/day, 49.392 hours/ns, 5.624 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 | 177.26 | 177.26 | 177.26 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10159 | 0.10159 | 0.10159 | 0.0 | 0.06 Output | 0.00015585 | 0.00015585 | 0.00015585 | 0.0 | 0.00 Modify | 0.38091 | 0.38091 | 0.38091 | 0.0 | 0.21 Other | | 0.06212 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134858.0 ave 134858 max 134858 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134858 Ave neighs/atom = 67.429000 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.745466491574, Press = 0.364980886385279 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 48000 -10443.69 -10443.69 -10520.201 -10520.201 296.10462 296.10462 28031.351 28031.351 556.32534 556.32534 49000 -10448.459 -10448.459 -10523.236 -10523.236 289.39291 289.39291 28049.654 28049.654 -823.2714 -823.2714 Loop time of 177.378 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.272 hours/ns, 5.638 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 176.84 | 176.84 | 176.84 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099109 | 0.099109 | 0.099109 | 0.0 | 0.06 Output | 0.00015572 | 0.00015572 | 0.00015572 | 0.0 | 0.00 Modify | 0.37611 | 0.37611 | 0.37611 | 0.0 | 0.21 Other | | 0.06172 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135042.0 ave 135042 max 135042 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135042 Ave neighs/atom = 67.521000 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.727788257273, Press = 0.583124757494244 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 49000 -10448.459 -10448.459 -10523.236 -10523.236 289.39291 289.39291 28049.654 28049.654 -823.2714 -823.2714 50000 -10444.29 -10444.29 -10519.512 -10519.512 291.11464 291.11464 28044.594 28044.594 -335.08706 -335.08706 Loop time of 178.875 on 1 procs for 1000 steps with 2000 atoms Performance: 0.483 ns/day, 49.688 hours/ns, 5.590 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 | 178.33 | 178.33 | 178.33 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10015 | 0.10015 | 0.10015 | 0.0 | 0.06 Output | 0.00020925 | 0.00020925 | 0.00020925 | 0.0 | 0.00 Modify | 0.38312 | 0.38312 | 0.38312 | 0.0 | 0.21 Other | | 0.06183 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134508.0 ave 134508 max 134508 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134508 Ave neighs/atom = 67.254000 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.71703139199, Press = -1.28990869700266 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 50000 -10444.29 -10444.29 -10519.512 -10519.512 291.11464 291.11464 28044.594 28044.594 -335.08706 -335.08706 51000 -10446.327 -10446.327 -10519.487 -10519.487 283.13534 283.13534 28000.336 28000.336 2213.6141 2213.6141 Loop time of 180.489 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.136 hours/ns, 5.541 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 | 179.94 | 179.94 | 179.94 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10163 | 0.10163 | 0.10163 | 0.0 | 0.06 Output | 0.0001523 | 0.0001523 | 0.0001523 | 0.0 | 0.00 Modify | 0.38643 | 0.38643 | 0.38643 | 0.0 | 0.21 Other | | 0.06203 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135164.0 ave 135164 max 135164 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135164 Ave neighs/atom = 67.582000 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.65947081145, Press = 1.09669748233004 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 51000 -10446.327 -10446.327 -10519.487 -10519.487 283.13534 283.13534 28000.336 28000.336 2213.6141 2213.6141 52000 -10442.639 -10442.639 -10517.43 -10517.43 289.44809 289.44809 28078.715 28078.715 -1842.0599 -1842.0599 Loop time of 181.866 on 1 procs for 1000 steps with 2000 atoms Performance: 0.475 ns/day, 50.518 hours/ns, 5.499 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 | 181.31 | 181.31 | 181.31 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10212 | 0.10212 | 0.10212 | 0.0 | 0.06 Output | 0.00015666 | 0.00015666 | 0.00015666 | 0.0 | 0.00 Modify | 0.38882 | 0.38882 | 0.38882 | 0.0 | 0.21 Other | | 0.06202 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135296.0 ave 135296 max 135296 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135296 Ave neighs/atom = 67.648000 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.691222106809, Press = 0.77446048847533 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 52000 -10442.639 -10442.639 -10517.43 -10517.43 289.44809 289.44809 28078.715 28078.715 -1842.0599 -1842.0599 53000 -10444.912 -10444.912 -10521.498 -10521.498 296.39389 296.39389 28045.968 28045.968 -343.38737 -343.38737 Loop time of 179.186 on 1 procs for 1000 steps with 2000 atoms Performance: 0.482 ns/day, 49.774 hours/ns, 5.581 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 | 178.64 | 178.64 | 178.64 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10054 | 0.10054 | 0.10054 | 0.0 | 0.06 Output | 0.00015666 | 0.00015666 | 0.00015666 | 0.0 | 0.00 Modify | 0.38153 | 0.38153 | 0.38153 | 0.0 | 0.21 Other | | 0.06176 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134796.0 ave 134796 max 134796 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134796 Ave neighs/atom = 67.398000 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.715970661336, Press = -0.477935567507665 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 53000 -10444.912 -10444.912 -10521.498 -10521.498 296.39389 296.39389 28045.968 28045.968 -343.38737 -343.38737 54000 -10441.303 -10441.303 -10519.386 -10519.386 302.18974 302.18974 28030.329 28030.329 853.54727 853.54727 Loop time of 180.152 on 1 procs for 1000 steps with 2000 atoms Performance: 0.480 ns/day, 50.042 hours/ns, 5.551 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 | 179.6 | 179.6 | 179.6 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10132 | 0.10132 | 0.10132 | 0.0 | 0.06 Output | 0.00015265 | 0.00015265 | 0.00015265 | 0.0 | 0.00 Modify | 0.38988 | 0.38988 | 0.38988 | 0.0 | 0.22 Other | | 0.06283 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134878.0 ave 134878 max 134878 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134878 Ave neighs/atom = 67.439000 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.797894582526, Press = 0.605059126767528 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 54000 -10441.303 -10441.303 -10519.386 -10519.386 302.18974 302.18974 28030.329 28030.329 853.54727 853.54727 55000 -10445.692 -10445.692 -10521.651 -10521.651 293.96834 293.96834 28042.289 28042.289 -21.842083 -21.842083 Loop time of 181.592 on 1 procs for 1000 steps with 2000 atoms Performance: 0.476 ns/day, 50.442 hours/ns, 5.507 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 | 181.04 | 181.04 | 181.04 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10224 | 0.10224 | 0.10224 | 0.0 | 0.06 Output | 0.000153 | 0.000153 | 0.000153 | 0.0 | 0.00 Modify | 0.39074 | 0.39074 | 0.39074 | 0.0 | 0.22 Other | | 0.06248 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135040.0 ave 135040 max 135040 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135040 Ave neighs/atom = 67.520000 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.82189073451, Press = 0.363379809792538 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 55000 -10445.692 -10445.692 -10521.651 -10521.651 293.96834 293.96834 28042.289 28042.289 -21.842083 -21.842083 56000 -10443.291 -10443.291 -10517.989 -10517.989 289.08589 289.08589 28043.621 28043.621 -24.528918 -24.528918 Loop time of 180.515 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.143 hours/ns, 5.540 timesteps/s 99.9% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 179.97 | 179.97 | 179.97 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10209 | 0.10209 | 0.10209 | 0.0 | 0.06 Output | 0.00015343 | 0.00015343 | 0.00015343 | 0.0 | 0.00 Modify | 0.38509 | 0.38509 | 0.38509 | 0.0 | 0.21 Other | | 0.06195 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134648.0 ave 134648 max 134648 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134648 Ave neighs/atom = 67.324000 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.851657446612, Press = 0.160453102540906 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 56000 -10443.291 -10443.291 -10517.989 -10517.989 289.08589 289.08589 28043.621 28043.621 -24.528918 -24.528918 57000 -10447.556 -10447.556 -10522.146 -10522.146 288.6688 288.6688 28035.48 28035.48 139.11478 139.11478 Loop time of 175.813 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.837 hours/ns, 5.688 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 | 175.28 | 175.28 | 175.28 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099171 | 0.099171 | 0.099171 | 0.0 | 0.06 Output | 0.00015549 | 0.00015549 | 0.00015549 | 0.0 | 0.00 Modify | 0.37285 | 0.37285 | 0.37285 | 0.0 | 0.21 Other | | 0.06099 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135058.0 ave 135058 max 135058 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135058 Ave neighs/atom = 67.529000 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.85358948993, Press = 0.137540031834469 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 57000 -10447.556 -10447.556 -10522.146 -10522.146 288.6688 288.6688 28035.48 28035.48 139.11478 139.11478 58000 -10443.838 -10443.838 -10520.736 -10520.736 297.60304 297.60304 28045.685 28045.685 -238.64433 -238.64433 Loop time of 176.593 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.054 hours/ns, 5.663 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 | 176.05 | 176.05 | 176.05 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09984 | 0.09984 | 0.09984 | 0.0 | 0.06 Output | 0.00015607 | 0.00015607 | 0.00015607 | 0.0 | 0.00 Modify | 0.37701 | 0.37701 | 0.37701 | 0.0 | 0.21 Other | | 0.06153 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134632.0 ave 134632 max 134632 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134632 Ave neighs/atom = 67.316000 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.826617816931, Press = 0.0969069724671704 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 58000 -10443.838 -10443.838 -10520.736 -10520.736 297.60304 297.60304 28045.685 28045.685 -238.64433 -238.64433 59000 -10443.351 -10443.351 -10520.072 -10520.072 296.91813 296.91813 28047.248 28047.248 -299.77471 -299.77471 Loop time of 176.818 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.116 hours/ns, 5.656 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 | 176.28 | 176.28 | 176.28 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099826 | 0.099826 | 0.099826 | 0.0 | 0.06 Output | 0.00015784 | 0.00015784 | 0.00015784 | 0.0 | 0.00 Modify | 0.37669 | 0.37669 | 0.37669 | 0.0 | 0.21 Other | | 0.06144 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134890.0 ave 134890 max 134890 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134890 Ave neighs/atom = 67.445000 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.810763377141, Press = 0.00377066842600848 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 59000 -10443.351 -10443.351 -10520.072 -10520.072 296.91813 296.91813 28047.248 28047.248 -299.77471 -299.77471 60000 -10446.131 -10446.131 -10521.731 -10521.731 292.57882 292.57882 28032.744 28032.744 232.2968 232.2968 Loop time of 179.457 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.849 hours/ns, 5.572 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 | 178.91 | 178.91 | 178.91 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.101 | 0.101 | 0.101 | 0.0 | 0.06 Output | 0.00015574 | 0.00015574 | 0.00015574 | 0.0 | 0.00 Modify | 0.38463 | 0.38463 | 0.38463 | 0.0 | 0.21 Other | | 0.06146 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134944.0 ave 134944 max 134944 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134944 Ave neighs/atom = 67.472000 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.776755775043, Press = 0.0666271208416143 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 60000 -10446.131 -10446.131 -10521.731 -10521.731 292.57882 292.57882 28032.744 28032.744 232.2968 232.2968 61000 -10446.56 -10446.56 -10520.868 -10520.868 287.5802 287.5802 28039.967 28039.967 -40.904354 -40.904354 Loop time of 177.347 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.263 hours/ns, 5.639 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 | 176.81 | 176.81 | 176.81 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10015 | 0.10015 | 0.10015 | 0.0 | 0.06 Output | 0.00015787 | 0.00015787 | 0.00015787 | 0.0 | 0.00 Modify | 0.37769 | 0.37769 | 0.37769 | 0.0 | 0.21 Other | | 0.06183 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134838.0 ave 134838 max 134838 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134838 Ave neighs/atom = 67.419000 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.781634413075, Press = 0.680742153952755 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 61000 -10446.56 -10446.56 -10520.868 -10520.868 287.5802 287.5802 28039.967 28039.967 -40.904354 -40.904354 62000 -10444.169 -10444.169 -10519.843 -10519.843 292.8671 292.8671 28076.148 28076.148 -1917.0965 -1917.0965 Loop time of 175.095 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.638 hours/ns, 5.711 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 | 174.57 | 174.57 | 174.57 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098877 | 0.098877 | 0.098877 | 0.0 | 0.06 Output | 0.00019565 | 0.00019565 | 0.00019565 | 0.0 | 0.00 Modify | 0.36954 | 0.36954 | 0.36954 | 0.0 | 0.21 Other | | 0.06125 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134780.0 ave 134780 max 134780 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134780 Ave neighs/atom = 67.390000 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.774617680356, Press = -0.691518035744532 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 62000 -10444.169 -10444.169 -10519.843 -10519.843 292.8671 292.8671 28076.148 28076.148 -1917.0965 -1917.0965 63000 -10446.719 -10446.719 -10521.344 -10521.344 288.80803 288.80803 27993.749 27993.749 2383.3483 2383.3483 Loop time of 177.897 on 1 procs for 1000 steps with 2000 atoms Performance: 0.486 ns/day, 49.416 hours/ns, 5.621 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 | 177.35 | 177.35 | 177.35 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10154 | 0.10154 | 0.10154 | 0.0 | 0.06 Output | 0.00015582 | 0.00015582 | 0.00015582 | 0.0 | 0.00 Modify | 0.38253 | 0.38253 | 0.38253 | 0.0 | 0.22 Other | | 0.06204 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134652.0 ave 134652 max 134652 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134652 Ave neighs/atom = 67.326000 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.799350658943, Press = -0.182137739455805 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 63000 -10446.719 -10446.719 -10521.344 -10521.344 288.80803 288.80803 27993.749 27993.749 2383.3483 2383.3483 64000 -10444.228 -10444.228 -10520.571 -10520.571 295.45342 295.45342 28047.947 28047.947 -479.33517 -479.33517 Loop time of 176.508 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.030 hours/ns, 5.665 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 | 175.97 | 175.97 | 175.97 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099801 | 0.099801 | 0.099801 | 0.0 | 0.06 Output | 0.00015631 | 0.00015631 | 0.00015631 | 0.0 | 0.00 Modify | 0.37553 | 0.37553 | 0.37553 | 0.0 | 0.21 Other | | 0.06099 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135146.0 ave 135146 max 135146 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135146 Ave neighs/atom = 67.573000 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.796648204518, Press = 0.851872671207196 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 64000 -10444.228 -10444.228 -10520.571 -10520.571 295.45342 295.45342 28047.947 28047.947 -479.33517 -479.33517 65000 -10444.87 -10444.87 -10521.082 -10521.082 294.94808 294.94808 28053.483 28053.483 -778.46389 -778.46389 Loop time of 176.167 on 1 procs for 1000 steps with 2000 atoms Performance: 0.490 ns/day, 48.935 hours/ns, 5.676 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 | 175.63 | 175.63 | 175.63 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099862 | 0.099862 | 0.099862 | 0.0 | 0.06 Output | 0.00014991 | 0.00014991 | 0.00014991 | 0.0 | 0.00 Modify | 0.37728 | 0.37728 | 0.37728 | 0.0 | 0.21 Other | | 0.06163 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134868.0 ave 134868 max 134868 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134868 Ave neighs/atom = 67.434000 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.806514379779, Press = -0.265334337306686 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 65000 -10444.87 -10444.87 -10521.082 -10521.082 294.94808 294.94808 28053.483 28053.483 -778.46389 -778.46389 66000 -10443.048 -10443.048 -10520.001 -10520.001 297.81654 297.81654 28038.341 28038.341 230.06579 230.06579 Loop time of 176.103 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.917 hours/ns, 5.678 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 | 175.57 | 175.57 | 175.57 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099563 | 0.099563 | 0.099563 | 0.0 | 0.06 Output | 0.00015931 | 0.00015931 | 0.00015931 | 0.0 | 0.00 Modify | 0.37623 | 0.37623 | 0.37623 | 0.0 | 0.21 Other | | 0.06177 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134680.0 ave 134680 max 134680 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134680 Ave neighs/atom = 67.340000 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.826087012224, Press = -0.063018210596695 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 66000 -10443.048 -10443.048 -10520.001 -10520.001 297.81654 297.81654 28038.341 28038.341 230.06579 230.06579 67000 -10444.715 -10444.715 -10517.575 -10517.575 281.97445 281.97445 28043.821 28043.821 -1.0021001 -1.0021001 Loop time of 177.265 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.240 hours/ns, 5.641 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 | 176.73 | 176.73 | 176.73 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099945 | 0.099945 | 0.099945 | 0.0 | 0.06 Output | 0.00041765 | 0.00041765 | 0.00041765 | 0.0 | 0.00 Modify | 0.37708 | 0.37708 | 0.37708 | 0.0 | 0.21 Other | | 0.06151 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135030.0 ave 135030 max 135030 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135030 Ave neighs/atom = 67.515000 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.799688011512, Press = 0.0302557325893388 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 67000 -10444.715 -10444.715 -10517.575 -10517.575 281.97445 281.97445 28043.821 28043.821 -1.0021001 -1.0021001 68000 -10447.565 -10447.565 -10521.692 -10521.692 286.88065 286.88065 28034.745 28034.745 246.6682 246.6682 Loop time of 177.901 on 1 procs for 1000 steps with 2000 atoms Performance: 0.486 ns/day, 49.417 hours/ns, 5.621 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 | 177.36 | 177.36 | 177.36 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10072 | 0.10072 | 0.10072 | 0.0 | 0.06 Output | 0.00021421 | 0.00021421 | 0.00021421 | 0.0 | 0.00 Modify | 0.37952 | 0.37952 | 0.37952 | 0.0 | 0.21 Other | | 0.06221 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134980.0 ave 134980 max 134980 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134980 Ave neighs/atom = 67.490000 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.784574854665, Press = -0.279855844565817 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 68000 -10447.565 -10447.565 -10521.692 -10521.692 286.88065 286.88065 28034.745 28034.745 246.6682 246.6682 69000 -10443.855 -10443.855 -10518.709 -10518.709 289.68976 289.68976 28026.813 28026.813 1032.0305 1032.0305 Loop time of 180.031 on 1 procs for 1000 steps with 2000 atoms Performance: 0.480 ns/day, 50.008 hours/ns, 5.555 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 | 179.48 | 179.48 | 179.48 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10157 | 0.10157 | 0.10157 | 0.0 | 0.06 Output | 0.00015471 | 0.00015471 | 0.00015471 | 0.0 | 0.00 Modify | 0.38939 | 0.38939 | 0.38939 | 0.0 | 0.22 Other | | 0.06273 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134830.0 ave 134830 max 134830 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134830 Ave neighs/atom = 67.415000 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.755550953829, Press = 0.187993070457143 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 69000 -10443.855 -10443.855 -10518.709 -10518.709 289.68976 289.68976 28026.813 28026.813 1032.0305 1032.0305 70000 -10445.662 -10445.662 -10521.333 -10521.333 292.85324 292.85324 28061.121 28061.121 -1075.2814 -1075.2814 Loop time of 174.787 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.552 hours/ns, 5.721 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 | 174.26 | 174.26 | 174.26 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099621 | 0.099621 | 0.099621 | 0.0 | 0.06 Output | 0.00015398 | 0.00015398 | 0.00015398 | 0.0 | 0.00 Modify | 0.36893 | 0.36893 | 0.36893 | 0.0 | 0.21 Other | | 0.06055 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135182.0 ave 135182 max 135182 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135182 Ave neighs/atom = 67.591000 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.776036987256, Press = 0.104334728447054 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 70000 -10445.662 -10445.662 -10521.333 -10521.333 292.85324 292.85324 28061.121 28061.121 -1075.2814 -1075.2814 71000 -10441.806 -10441.806 -10518.779 -10518.779 297.89188 297.89188 28051.5 28051.5 -354.35113 -354.35113 Loop time of 175.252 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.681 hours/ns, 5.706 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 | 174.72 | 174.72 | 174.72 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099248 | 0.099248 | 0.099248 | 0.0 | 0.06 Output | 0.00020225 | 0.00020225 | 0.00020225 | 0.0 | 0.00 Modify | 0.37198 | 0.37198 | 0.37198 | 0.0 | 0.21 Other | | 0.06097 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134554.0 ave 134554 max 134554 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134554 Ave neighs/atom = 67.277000 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.817112675272, Press = -0.812324867216184 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 71000 -10441.806 -10441.806 -10518.779 -10518.779 297.89188 297.89188 28051.5 28051.5 -354.35113 -354.35113 72000 -10446.78 -10446.78 -10521.844 -10521.844 290.50687 290.50687 27993.369 27993.369 2398.5064 2398.5064 Loop time of 177.408 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.280 hours/ns, 5.637 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 | 176.87 | 176.87 | 176.87 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10025 | 0.10025 | 0.10025 | 0.0 | 0.06 Output | 0.00015651 | 0.00015651 | 0.00015651 | 0.0 | 0.00 Modify | 0.38093 | 0.38093 | 0.38093 | 0.0 | 0.21 Other | | 0.06214 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134972.0 ave 134972 max 134972 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134972 Ave neighs/atom = 67.486000 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.837840077205, Press = 0.369717753794585 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 72000 -10446.78 -10446.78 -10521.844 -10521.844 290.50687 290.50687 27993.369 27993.369 2398.5064 2398.5064 73000 -10444.275 -10444.275 -10520.419 -10520.419 294.68511 294.68511 28082.777 28082.777 -2231.601 -2231.601 Loop time of 180.762 on 1 procs for 1000 steps with 2000 atoms Performance: 0.478 ns/day, 50.212 hours/ns, 5.532 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 | 180.21 | 180.21 | 180.21 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10225 | 0.10225 | 0.10225 | 0.0 | 0.06 Output | 0.00015848 | 0.00015848 | 0.00015848 | 0.0 | 0.00 Modify | 0.38835 | 0.38835 | 0.38835 | 0.0 | 0.21 Other | | 0.06244 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134840.0 ave 134840 max 134840 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134840 Ave neighs/atom = 67.420000 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.837217084175, Press = 0.584377619408718 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 73000 -10444.275 -10444.275 -10520.419 -10520.419 294.68511 294.68511 28082.777 28082.777 -2231.601 -2231.601 74000 -10446.277 -10446.277 -10521.569 -10521.569 291.38678 291.38678 28045.513 28045.513 -366.93291 -366.93291 Loop time of 176.732 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.092 hours/ns, 5.658 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 | 176.19 | 176.19 | 176.19 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099775 | 0.099775 | 0.099775 | 0.0 | 0.06 Output | 0.00015377 | 0.00015377 | 0.00015377 | 0.0 | 0.00 Modify | 0.37615 | 0.37615 | 0.37615 | 0.0 | 0.21 Other | | 0.06158 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134440.0 ave 134440 max 134440 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134440 Ave neighs/atom = 67.220000 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.81401203714, Press = -0.633810538641752 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 74000 -10446.277 -10446.277 -10521.569 -10521.569 291.38678 291.38678 28045.513 28045.513 -366.93291 -366.93291 75000 -10442.879 -10442.879 -10519.465 -10519.465 296.39688 296.39688 28028.342 28028.342 952.52312 952.52312 Loop time of 176.502 on 1 procs for 1000 steps with 2000 atoms Performance: 0.490 ns/day, 49.028 hours/ns, 5.666 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 | 175.97 | 175.97 | 175.97 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099965 | 0.099965 | 0.099965 | 0.0 | 0.06 Output | 0.00015644 | 0.00015644 | 0.00015644 | 0.0 | 0.00 Modify | 0.37356 | 0.37356 | 0.37356 | 0.0 | 0.21 Other | | 0.06162 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134838.0 ave 134838 max 134838 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134838 Ave neighs/atom = 67.419000 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.807703974514, Press = -0.0155598467319054 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 75000 -10442.879 -10442.879 -10519.465 -10519.465 296.39688 296.39688 28028.342 28028.342 952.52312 952.52312 76000 -10448.125 -10448.125 -10522.525 -10522.525 287.93672 287.93672 28047.695 28047.695 -679.83568 -679.83568 Loop time of 175.803 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.834 hours/ns, 5.688 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 | 175.27 | 175.27 | 175.27 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099159 | 0.099159 | 0.099159 | 0.0 | 0.06 Output | 0.00015777 | 0.00015777 | 0.00015777 | 0.0 | 0.00 Modify | 0.37248 | 0.37248 | 0.37248 | 0.0 | 0.21 Other | | 0.0612 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134982.0 ave 134982 max 134982 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134982 Ave neighs/atom = 67.491000 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.781503316714, Press = 0.1450860029328 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 76000 -10448.125 -10448.125 -10522.525 -10522.525 287.93672 287.93672 28047.695 28047.695 -679.83568 -679.83568 77000 -10443.565 -10443.565 -10520.197 -10520.197 296.57686 296.57686 28048.974 28048.974 -448.66554 -448.66554 Loop time of 176.801 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.111 hours/ns, 5.656 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 | 176.26 | 176.26 | 176.26 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09958 | 0.09958 | 0.09958 | 0.0 | 0.06 Output | 0.00015418 | 0.00015418 | 0.00015418 | 0.0 | 0.00 Modify | 0.37521 | 0.37521 | 0.37521 | 0.0 | 0.21 Other | | 0.06161 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134506.0 ave 134506 max 134506 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134506 Ave neighs/atom = 67.253000 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.774552761431, Press = -0.480028144951583 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 77000 -10443.565 -10443.565 -10520.197 -10520.197 296.57686 296.57686 28048.974 28048.974 -448.66554 -448.66554 78000 -10446.771 -10446.771 -10521.825 -10521.825 290.46801 290.46801 28008.574 28008.574 1593.7831 1593.7831 Loop time of 174.755 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.543 hours/ns, 5.722 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 | 174.23 | 174.23 | 174.23 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098004 | 0.098004 | 0.098004 | 0.0 | 0.06 Output | 0.00015748 | 0.00015748 | 0.00015748 | 0.0 | 0.00 Modify | 0.36843 | 0.36843 | 0.36843 | 0.0 | 0.21 Other | | 0.06086 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134844.0 ave 134844 max 134844 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134844 Ave neighs/atom = 67.422000 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.757517540316, Press = 0.0438043545222928 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 78000 -10446.771 -10446.771 -10521.825 -10521.825 290.46801 290.46801 28008.574 28008.574 1593.7831 1593.7831 79000 -10444.59 -10444.59 -10521.086 -10521.086 296.04724 296.04724 28063.107 28063.107 -1126.78 -1126.78 Loop time of 176.1 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.917 hours/ns, 5.679 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 | 175.56 | 175.56 | 175.56 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099885 | 0.099885 | 0.099885 | 0.0 | 0.06 Output | 0.00020283 | 0.00020283 | 0.00020283 | 0.0 | 0.00 Modify | 0.37329 | 0.37329 | 0.37329 | 0.0 | 0.21 Other | | 0.06163 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135030.0 ave 135030 max 135030 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135030 Ave neighs/atom = 67.515000 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.773154297783, Press = 0.48414916264188 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 79000 -10444.59 -10444.59 -10521.086 -10521.086 296.04724 296.04724 28063.107 28063.107 -1126.78 -1126.78 80000 -10445.187 -10445.187 -10519.75 -10519.75 288.56599 288.56599 28055.978 28055.978 -837.49863 -837.49863 Loop time of 175.975 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.882 hours/ns, 5.683 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 175.44 | 175.44 | 175.44 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099865 | 0.099865 | 0.099865 | 0.0 | 0.06 Output | 0.00015728 | 0.00015728 | 0.00015728 | 0.0 | 0.00 Modify | 0.37547 | 0.37547 | 0.37547 | 0.0 | 0.21 Other | | 0.06212 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134726.0 ave 134726 max 134726 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134726 Ave neighs/atom = 67.363000 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.759601933776, Press = -0.947875442014829 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 80000 -10445.187 -10445.187 -10519.75 -10519.75 288.56599 288.56599 28055.978 28055.978 -837.49863 -837.49863 81000 -10446.983 -10446.983 -10522.159 -10522.159 290.94084 290.94084 28001.49 28001.49 1959.022 1959.022 Loop time of 174.095 on 1 procs for 1000 steps with 2000 atoms Performance: 0.496 ns/day, 48.360 hours/ns, 5.744 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 | 173.57 | 173.57 | 173.57 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098968 | 0.098968 | 0.098968 | 0.0 | 0.06 Output | 0.00020548 | 0.00020548 | 0.00020548 | 0.0 | 0.00 Modify | 0.36607 | 0.36607 | 0.36607 | 0.0 | 0.21 Other | | 0.06058 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134732.0 ave 134732 max 134732 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134732 Ave neighs/atom = 67.366000 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.77279502112, Press = 0.0251351055278009 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 81000 -10446.983 -10446.983 -10522.159 -10522.159 290.94084 290.94084 28001.49 28001.49 1959.022 1959.022 82000 -10443.981 -10443.981 -10518.545 -10518.545 288.57226 288.57226 28056.788 28056.788 -618.32901 -618.32901 Loop time of 174.203 on 1 procs for 1000 steps with 2000 atoms Performance: 0.496 ns/day, 48.390 hours/ns, 5.740 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 | 173.68 | 173.68 | 173.68 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097819 | 0.097819 | 0.097819 | 0.0 | 0.06 Output | 0.00021853 | 0.00021853 | 0.00021853 | 0.0 | 0.00 Modify | 0.36768 | 0.36768 | 0.36768 | 0.0 | 0.21 Other | | 0.06107 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134930.0 ave 134930 max 134930 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134930 Ave neighs/atom = 67.465000 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.74480271265, Press = 0.170259882422016 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 82000 -10443.981 -10443.981 -10518.545 -10518.545 288.57226 288.57226 28056.788 28056.788 -618.32901 -618.32901 83000 -10446.093 -10446.093 -10521.346 -10521.346 291.23848 291.23848 28039.999 28039.999 -26.442459 -26.442459 Loop time of 171.833 on 1 procs for 1000 steps with 2000 atoms Performance: 0.503 ns/day, 47.731 hours/ns, 5.820 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 171.31 | 171.31 | 171.31 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097264 | 0.097264 | 0.097264 | 0.0 | 0.06 Output | 0.00015655 | 0.00015655 | 0.00015655 | 0.0 | 0.00 Modify | 0.36184 | 0.36184 | 0.36184 | 0.0 | 0.21 Other | | 0.0605 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134828.0 ave 134828 max 134828 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134828 Ave neighs/atom = 67.414000 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.733326730013, Press = -0.365514643915847 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 83000 -10446.093 -10446.093 -10521.346 -10521.346 291.23848 291.23848 28039.999 28039.999 -26.442459 -26.442459 84000 -10443.876 -10443.876 -10520.39 -10520.39 296.11887 296.11887 28027.739 28027.739 662.4905 662.4905 Loop time of 173.11 on 1 procs for 1000 steps with 2000 atoms Performance: 0.499 ns/day, 48.086 hours/ns, 5.777 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 | 172.58 | 172.58 | 172.58 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097966 | 0.097966 | 0.097966 | 0.0 | 0.06 Output | 0.00015571 | 0.00015571 | 0.00015571 | 0.0 | 0.00 Modify | 0.36715 | 0.36715 | 0.36715 | 0.0 | 0.21 Other | | 0.06124 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134760.0 ave 134760 max 134760 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134760 Ave neighs/atom = 67.380000 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.720531675584, Press = -0.158986475014063 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 84000 -10443.876 -10443.876 -10520.39 -10520.39 296.11887 296.11887 28027.739 28027.739 662.4905 662.4905 85000 -10447.411 -10447.411 -10522.515 -10522.515 290.65908 290.65908 28028.347 28028.347 565.01815 565.01815 Loop time of 171.831 on 1 procs for 1000 steps with 2000 atoms Performance: 0.503 ns/day, 47.731 hours/ns, 5.820 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 171.31 | 171.31 | 171.31 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097038 | 0.097038 | 0.097038 | 0.0 | 0.06 Output | 0.00015719 | 0.00015719 | 0.00015719 | 0.0 | 0.00 Modify | 0.36343 | 0.36343 | 0.36343 | 0.0 | 0.21 Other | | 0.06047 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134816.0 ave 134816 max 134816 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134816 Ave neighs/atom = 67.408000 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.72304667023, Press = 0.114002895096039 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 85000 -10447.411 -10447.411 -10522.515 -10522.515 290.65908 290.65908 28028.347 28028.347 565.01815 565.01815 86000 -10443.333 -10443.333 -10518.173 -10518.173 289.64122 289.64122 28092.913 28092.913 -2677.8992 -2677.8992 Loop time of 174.214 on 1 procs for 1000 steps with 2000 atoms Performance: 0.496 ns/day, 48.393 hours/ns, 5.740 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 | 173.69 | 173.69 | 173.69 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09794 | 0.09794 | 0.09794 | 0.0 | 0.06 Output | 0.00015688 | 0.00015688 | 0.00015688 | 0.0 | 0.00 Modify | 0.36677 | 0.36677 | 0.36677 | 0.0 | 0.21 Other | | 0.06145 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134746.0 ave 134746 max 134746 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134746 Ave neighs/atom = 67.373000 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.702278987213, Press = -0.140089492094772 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 86000 -10443.333 -10443.333 -10518.173 -10518.173 289.64122 289.64122 28092.913 28092.913 -2677.8992 -2677.8992 87000 -10446.8 -10446.8 -10522.787 -10522.787 294.07783 294.07783 28019.173 28019.173 868.77672 868.77672 Loop time of 172.335 on 1 procs for 1000 steps with 2000 atoms Performance: 0.501 ns/day, 47.871 hours/ns, 5.803 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 171.81 | 171.81 | 171.81 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097741 | 0.097741 | 0.097741 | 0.0 | 0.06 Output | 0.00016948 | 0.00016948 | 0.00016948 | 0.0 | 0.00 Modify | 0.36258 | 0.36258 | 0.36258 | 0.0 | 0.21 Other | | 0.06053 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134652.0 ave 134652 max 134652 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134652 Ave neighs/atom = 67.326000 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.706579041416, Press = -0.813753256113192 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 87000 -10446.8 -10446.8 -10522.787 -10522.787 294.07783 294.07783 28019.173 28019.173 868.77672 868.77672 88000 -10443.563 -10443.563 -10519.67 -10519.67 294.54149 294.54149 28025.908 28025.908 972.97185 972.97185 Loop time of 175.63 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.786 hours/ns, 5.694 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 | 175.1 | 175.1 | 175.1 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099585 | 0.099585 | 0.099585 | 0.0 | 0.06 Output | 0.00015301 | 0.00015301 | 0.00015301 | 0.0 | 0.00 Modify | 0.37218 | 0.37218 | 0.37218 | 0.0 | 0.21 Other | | 0.06153 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134828.0 ave 134828 max 134828 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134828 Ave neighs/atom = 67.414000 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.693378959967, Press = 0.337893122781448 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 88000 -10443.563 -10443.563 -10519.67 -10519.67 294.54149 294.54149 28025.908 28025.908 972.97185 972.97185 89000 -10444.521 -10444.521 -10519.072 -10519.072 288.52108 288.52108 28062.275 28062.275 -1031.7219 -1031.7219 Loop time of 174.522 on 1 procs for 1000 steps with 2000 atoms Performance: 0.495 ns/day, 48.478 hours/ns, 5.730 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 | 173.99 | 173.99 | 173.99 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098782 | 0.098782 | 0.098782 | 0.0 | 0.06 Output | 0.00015667 | 0.00015667 | 0.00015667 | 0.0 | 0.00 Modify | 0.37181 | 0.37181 | 0.37181 | 0.0 | 0.21 Other | | 0.0617 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134902.0 ave 134902 max 134902 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134902 Ave neighs/atom = 67.451000 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.687984143001, Press = -0.152579973974211 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 89000 -10444.521 -10444.521 -10519.072 -10519.072 288.52108 288.52108 28062.275 28062.275 -1031.7219 -1031.7219 90000 -10443.997 -10443.997 -10521.193 -10521.193 298.75774 298.75774 28034.773 28034.773 305.27399 305.27399 Loop time of 176.934 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.148 hours/ns, 5.652 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 | 176.4 | 176.4 | 176.4 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099479 | 0.099479 | 0.099479 | 0.0 | 0.06 Output | 0.00015503 | 0.00015503 | 0.00015503 | 0.0 | 0.00 Modify | 0.3765 | 0.3765 | 0.3765 | 0.0 | 0.21 Other | | 0.06183 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134592.0 ave 134592 max 134592 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134592 Ave neighs/atom = 67.296000 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.695713246444, Press = -0.477637564507222 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 90000 -10443.997 -10443.997 -10521.193 -10521.193 298.75774 298.75774 28034.773 28034.773 305.27399 305.27399 91000 -10446.953 -10446.953 -10520.186 -10520.186 283.417 283.417 28015.797 28015.797 1289.3265 1289.3265 Loop time of 173.123 on 1 procs for 1000 steps with 2000 atoms Performance: 0.499 ns/day, 48.090 hours/ns, 5.776 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 | 172.6 | 172.6 | 172.6 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09681 | 0.09681 | 0.09681 | 0.0 | 0.06 Output | 0.00019978 | 0.00019978 | 0.00019978 | 0.0 | 0.00 Modify | 0.36488 | 0.36488 | 0.36488 | 0.0 | 0.21 Other | | 0.06119 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134788.0 ave 134788 max 134788 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134788 Ave neighs/atom = 67.394000 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.722113961682, Press = 0.154579119339676 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 91000 -10446.953 -10446.953 -10520.186 -10520.186 283.417 283.417 28015.797 28015.797 1289.3265 1289.3265 92000 -10447.541 -10447.541 -10521.618 -10521.618 286.68519 286.68519 28085.615 28085.615 -2515.8978 -2515.8978 Loop time of 175.852 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.848 hours/ns, 5.687 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 | 175.32 | 175.32 | 175.32 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098497 | 0.098497 | 0.098497 | 0.0 | 0.06 Output | 0.00015611 | 0.00015611 | 0.00015611 | 0.0 | 0.00 Modify | 0.37387 | 0.37387 | 0.37387 | 0.0 | 0.21 Other | | 0.0612 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134922.0 ave 134922 max 134922 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134922 Ave neighs/atom = 67.461000 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.721793455313, Press = 0.337340643151531 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 92000 -10447.541 -10447.541 -10521.618 -10521.618 286.68519 286.68519 28085.615 28085.615 -2515.8978 -2515.8978 93000 -10443.02 -10443.02 -10520.211 -10520.211 298.73852 298.73852 28056.58 28056.58 -729.81772 -729.81772 Loop time of 172.29 on 1 procs for 1000 steps with 2000 atoms Performance: 0.501 ns/day, 47.858 hours/ns, 5.804 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 | 171.77 | 171.77 | 171.77 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097104 | 0.097104 | 0.097104 | 0.0 | 0.06 Output | 0.0013422 | 0.0013422 | 0.0013422 | 0.0 | 0.00 Modify | 0.36327 | 0.36327 | 0.36327 | 0.0 | 0.21 Other | | 0.06107 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134374.0 ave 134374 max 134374 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134374 Ave neighs/atom = 67.187000 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.710036900193, Press = -0.981183981893984 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 93000 -10443.02 -10443.02 -10520.211 -10520.211 298.73852 298.73852 28056.58 28056.58 -729.81772 -729.81772 94000 -10447.603 -10447.603 -10522.409 -10522.409 289.50554 289.50554 28005.725 28005.725 1689.7506 1689.7506 Loop time of 173.196 on 1 procs for 1000 steps with 2000 atoms Performance: 0.499 ns/day, 48.110 hours/ns, 5.774 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 | 172.67 | 172.67 | 172.67 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097474 | 0.097474 | 0.097474 | 0.0 | 0.06 Output | 0.00015615 | 0.00015615 | 0.00015615 | 0.0 | 0.00 Modify | 0.36286 | 0.36286 | 0.36286 | 0.0 | 0.21 Other | | 0.06102 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134760.0 ave 134760 max 134760 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134760 Ave neighs/atom = 67.380000 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.704775534955, Press = 0.0114404480294158 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 94000 -10447.603 -10447.603 -10522.409 -10522.409 289.50554 289.50554 28005.725 28005.725 1689.7506 1689.7506 95000 -10442.791 -10442.791 -10517.436 -10517.436 288.88333 288.88333 28061.468 28061.468 -870.60694 -870.60694 Loop time of 174.979 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.605 hours/ns, 5.715 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 | 174.45 | 174.45 | 174.45 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098774 | 0.098774 | 0.098774 | 0.0 | 0.06 Output | 0.00015671 | 0.00015671 | 0.00015671 | 0.0 | 0.00 Modify | 0.37042 | 0.37042 | 0.37042 | 0.0 | 0.21 Other | | 0.06051 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134736.0 ave 134736 max 134736 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134736 Ave neighs/atom = 67.368000 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.684837193402, Press = 0.110181467620866 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 95000 -10442.791 -10442.791 -10517.436 -10517.436 288.88333 288.88333 28061.468 28061.468 -870.60694 -870.60694 96000 -10445.173 -10445.173 -10519.988 -10519.988 289.54043 289.54043 28046.358 28046.358 -264.55968 -264.55968 Loop time of 174.014 on 1 procs for 1000 steps with 2000 atoms Performance: 0.497 ns/day, 48.337 hours/ns, 5.747 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 | 173.49 | 173.49 | 173.49 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097288 | 0.097288 | 0.097288 | 0.0 | 0.06 Output | 0.00015246 | 0.00015246 | 0.00015246 | 0.0 | 0.00 Modify | 0.3639 | 0.3639 | 0.3639 | 0.0 | 0.21 Other | | 0.06032 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134950.0 ave 134950 max 134950 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134950 Ave neighs/atom = 67.475000 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.686816024657, Press = -0.371552418436462 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 96000 -10445.173 -10445.173 -10519.988 -10519.988 289.54043 289.54043 28046.358 28046.358 -264.55968 -264.55968 97000 -10441.732 -10441.732 -10517.941 -10517.941 294.93966 294.93966 28024.134 28024.134 1289.0323 1289.0323 Loop time of 176.835 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.121 hours/ns, 5.655 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 | 176.3 | 176.3 | 176.3 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099663 | 0.099663 | 0.099663 | 0.0 | 0.06 Output | 0.00019485 | 0.00019485 | 0.00019485 | 0.0 | 0.00 Modify | 0.37602 | 0.37602 | 0.37602 | 0.0 | 0.21 Other | | 0.06159 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134710.0 ave 134710 max 134710 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134710 Ave neighs/atom = 67.355000 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.704707717234, Press = 0.00881856666834861 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 97000 -10441.732 -10441.732 -10517.941 -10517.941 294.93966 294.93966 28024.134 28024.134 1289.0323 1289.0323 98000 -10445.511 -10445.511 -10520.597 -10520.597 290.59294 290.59294 28053.758 28053.758 -721.26651 -721.26651 Loop time of 176.475 on 1 procs for 1000 steps with 2000 atoms Performance: 0.490 ns/day, 49.021 hours/ns, 5.667 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 | 175.94 | 175.94 | 175.94 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099123 | 0.099123 | 0.099123 | 0.0 | 0.06 Output | 0.0001556 | 0.0001556 | 0.0001556 | 0.0 | 0.00 Modify | 0.37333 | 0.37333 | 0.37333 | 0.0 | 0.21 Other | | 0.06169 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135130.0 ave 135130 max 135130 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135130 Ave neighs/atom = 67.565000 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.708040931228, Press = 0.220340479179909 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 98000 -10445.511 -10445.511 -10520.597 -10520.597 290.59294 290.59294 28053.758 28053.758 -721.26651 -721.26651 99000 -10447.178 -10447.178 -10521.762 -10521.762 288.64862 288.64862 28062.868 28062.868 -1467.6485 -1467.6485 Loop time of 180.245 on 1 procs for 1000 steps with 2000 atoms Performance: 0.479 ns/day, 50.068 hours/ns, 5.548 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 | 179.7 | 179.7 | 179.7 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10051 | 0.10051 | 0.10051 | 0.0 | 0.06 Output | 0.00020203 | 0.00020203 | 0.00020203 | 0.0 | 0.00 Modify | 0.38304 | 0.38304 | 0.38304 | 0.0 | 0.21 Other | | 0.0616 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134722.0 ave 134722 max 134722 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134722 Ave neighs/atom = 67.361000 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.708846202572, Press = -0.76258235612139 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 99000 -10447.178 -10447.178 -10521.762 -10521.762 288.64862 288.64862 28062.868 28062.868 -1467.6485 -1467.6485 100000 -10445.534 -10445.534 -10520.709 -10520.709 290.93331 290.93331 27996.645 27996.645 2297.7205 2297.7205 Loop time of 174.73 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.536 hours/ns, 5.723 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 | 174.2 | 174.2 | 174.2 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098059 | 0.098059 | 0.098059 | 0.0 | 0.06 Output | 0.00015616 | 0.00015616 | 0.00015616 | 0.0 | 0.00 Modify | 0.36993 | 0.36993 | 0.36993 | 0.0 | 0.21 Other | | 0.06141 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134628.0 ave 134628 max 134628 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134628 Ave neighs/atom = 67.314000 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.677963811934, Press = -0.0907513027930122 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 100000 -10445.534 -10445.534 -10520.709 -10520.709 290.93331 290.93331 27996.645 27996.645 2297.7205 2297.7205 101000 -10443.024 -10443.024 -10518.737 -10518.737 293.01761 293.01761 28053.473 28053.473 -546.90269 -546.90269 Loop time of 179.477 on 1 procs for 1000 steps with 2000 atoms Performance: 0.481 ns/day, 49.855 hours/ns, 5.572 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 | 178.93 | 178.93 | 178.93 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10105 | 0.10105 | 0.10105 | 0.0 | 0.06 Output | 0.0001564 | 0.0001564 | 0.0001564 | 0.0 | 0.00 Modify | 0.38237 | 0.38237 | 0.38237 | 0.0 | 0.21 Other | | 0.06235 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135188.0 ave 135188 max 135188 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135188 Ave neighs/atom = 67.594000 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.684000780181, Press = 0.367189253303821 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 101000 -10443.024 -10443.024 -10518.737 -10518.737 293.01761 293.01761 28053.473 28053.473 -546.90269 -546.90269 102000 -10443.5 -10443.5 -10518.606 -10518.606 290.66822 290.66822 28061.65 28061.65 -927.65689 -927.65689 Loop time of 178.331 on 1 procs for 1000 steps with 2000 atoms Performance: 0.484 ns/day, 49.536 hours/ns, 5.608 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 | 177.79 | 177.79 | 177.79 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099924 | 0.099924 | 0.099924 | 0.0 | 0.06 Output | 0.00021818 | 0.00021818 | 0.00021818 | 0.0 | 0.00 Modify | 0.37809 | 0.37809 | 0.37809 | 0.0 | 0.21 Other | | 0.06192 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134962.0 ave 134962 max 134962 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134962 Ave neighs/atom = 67.481000 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.674119834503, Press = -0.514909091722364 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 102000 -10443.5 -10443.5 -10518.606 -10518.606 290.66822 290.66822 28061.65 28061.65 -927.65689 -927.65689 103000 -10441.912 -10441.912 -10519.849 -10519.849 301.62512 301.62512 28005.807 28005.807 2050.7446 2050.7446 Loop time of 177.38 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.272 hours/ns, 5.638 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 176.84 | 176.84 | 176.84 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099594 | 0.099594 | 0.099594 | 0.0 | 0.06 Output | 0.00015536 | 0.00015536 | 0.00015536 | 0.0 | 0.00 Modify | 0.37519 | 0.37519 | 0.37519 | 0.0 | 0.21 Other | | 0.06135 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134730.0 ave 134730 max 134730 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134730 Ave neighs/atom = 67.365000 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.687022340565, Press = -0.123486463382346 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 103000 -10441.912 -10441.912 -10519.849 -10519.849 301.62512 301.62512 28005.807 28005.807 2050.7446 2050.7446 104000 -10448.23 -10448.23 -10521.473 -10521.473 283.4609 283.4609 28056.086 28056.086 -1008.6893 -1008.6893 Loop time of 175.501 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.750 hours/ns, 5.698 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 | 174.97 | 174.97 | 174.97 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099169 | 0.099169 | 0.099169 | 0.0 | 0.06 Output | 0.00019313 | 0.00019313 | 0.00019313 | 0.0 | 0.00 Modify | 0.36915 | 0.36915 | 0.36915 | 0.0 | 0.21 Other | | 0.06121 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135156.0 ave 135156 max 135156 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135156 Ave neighs/atom = 67.578000 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.680664835151, Press = 0.608210647436393 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 104000 -10448.23 -10448.23 -10521.473 -10521.473 283.4609 283.4609 28056.086 28056.086 -1008.6893 -1008.6893 105000 -10442.613 -10442.613 -10520.135 -10520.135 300.01832 300.01832 28097.856 28097.856 -2924.5724 -2924.5724 Loop time of 175.995 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.888 hours/ns, 5.682 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 | 175.46 | 175.46 | 175.46 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099853 | 0.099853 | 0.099853 | 0.0 | 0.06 Output | 0.00015539 | 0.00015539 | 0.00015539 | 0.0 | 0.00 Modify | 0.37256 | 0.37256 | 0.37256 | 0.0 | 0.21 Other | | 0.06115 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134554.0 ave 134554 max 134554 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134554 Ave neighs/atom = 67.277000 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.665198979815, Press = -0.808450913201651 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 105000 -10442.613 -10442.613 -10520.135 -10520.135 300.01832 300.01832 28097.856 28097.856 -2924.5724 -2924.5724 106000 -10444.933 -10444.933 -10520.525 -10520.525 292.55033 292.55033 28011.49 28011.49 1678.7424 1678.7424 Loop time of 172.505 on 1 procs for 1000 steps with 2000 atoms Performance: 0.501 ns/day, 47.918 hours/ns, 5.797 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 | 171.99 | 171.99 | 171.99 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098031 | 0.098031 | 0.098031 | 0.0 | 0.06 Output | 0.00015828 | 0.00015828 | 0.00015828 | 0.0 | 0.00 Modify | 0.35967 | 0.35967 | 0.35967 | 0.0 | 0.21 Other | | 0.06006 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134542.0 ave 134542 max 134542 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134542 Ave neighs/atom = 67.271000 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.675079904467, Press = -0.176813932285255 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 106000 -10444.933 -10444.933 -10520.525 -10520.525 292.55033 292.55033 28011.49 28011.49 1678.7424 1678.7424 107000 -10441.406 -10441.406 -10518.754 -10518.754 299.34582 299.34582 28049.429 28049.429 -205.95433 -205.95433 Loop time of 174.277 on 1 procs for 1000 steps with 2000 atoms Performance: 0.496 ns/day, 48.410 hours/ns, 5.738 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 | 173.75 | 173.75 | 173.75 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098494 | 0.098494 | 0.098494 | 0.0 | 0.06 Output | 0.00015733 | 0.00015733 | 0.00015733 | 0.0 | 0.00 Modify | 0.36742 | 0.36742 | 0.36742 | 0.0 | 0.21 Other | | 0.06129 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135098.0 ave 135098 max 135098 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135098 Ave neighs/atom = 67.549000 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.701629298139, Press = 0.136649351034383 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 107000 -10441.406 -10441.406 -10518.754 -10518.754 299.34582 299.34582 28049.429 28049.429 -205.95433 -205.95433 108000 -10446.279 -10446.279 -10521.093 -10521.093 289.53445 289.53445 28046.945 28046.945 -535.05083 -535.05083 Loop time of 175.884 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.857 hours/ns, 5.686 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 175.35 | 175.35 | 175.35 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098697 | 0.098697 | 0.098697 | 0.0 | 0.06 Output | 0.00015279 | 0.00015279 | 0.00015279 | 0.0 | 0.00 Modify | 0.3702 | 0.3702 | 0.3702 | 0.0 | 0.21 Other | | 0.06109 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134880.0 ave 134880 max 134880 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134880 Ave neighs/atom = 67.440000 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.716342292575, Press = -0.341684461962542 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 108000 -10446.279 -10446.279 -10521.093 -10521.093 289.53445 289.53445 28046.945 28046.945 -535.05083 -535.05083 109000 -10446.941 -10446.941 -10520.934 -10520.934 286.36141 286.36141 28003.379 28003.379 1891.8983 1891.8983 Loop time of 176.96 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.156 hours/ns, 5.651 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 | 176.42 | 176.42 | 176.42 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10137 | 0.10137 | 0.10137 | 0.0 | 0.06 Output | 0.00019117 | 0.00019117 | 0.00019117 | 0.0 | 0.00 Modify | 0.37628 | 0.37628 | 0.37628 | 0.0 | 0.21 Other | | 0.06152 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134766.0 ave 134766 max 134766 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134766 Ave neighs/atom = 67.383000 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.726354353207, Press = 0.0369678586337528 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 109000 -10446.941 -10446.941 -10520.934 -10520.934 286.36141 286.36141 28003.379 28003.379 1891.8983 1891.8983 110000 -10445.487 -10445.487 -10521.633 -10521.633 294.69053 294.69053 28075.071 28075.071 -1891.5168 -1891.5168 Loop time of 173.405 on 1 procs for 1000 steps with 2000 atoms Performance: 0.498 ns/day, 48.168 hours/ns, 5.767 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 | 172.88 | 172.88 | 172.88 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098119 | 0.098119 | 0.098119 | 0.0 | 0.06 Output | 0.00015298 | 0.00015298 | 0.00015298 | 0.0 | 0.00 Modify | 0.36391 | 0.36391 | 0.36391 | 0.0 | 0.21 Other | | 0.06066 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135146.0 ave 135146 max 135146 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135146 Ave neighs/atom = 67.573000 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.704735801906, Press = 0.433956399423236 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 110000 -10445.487 -10445.487 -10521.633 -10521.633 294.69053 294.69053 28075.071 28075.071 -1891.5168 -1891.5168 111000 -10443.976 -10443.976 -10520.574 -10520.574 296.4433 296.4433 28056.775 28056.775 -1009.2676 -1009.2676 Loop time of 172.223 on 1 procs for 1000 steps with 2000 atoms Performance: 0.502 ns/day, 47.840 hours/ns, 5.806 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 | 171.7 | 171.7 | 171.7 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097366 | 0.097366 | 0.097366 | 0.0 | 0.06 Output | 0.00016059 | 0.00016059 | 0.00016059 | 0.0 | 0.00 Modify | 0.36442 | 0.36442 | 0.36442 | 0.0 | 0.21 Other | | 0.06142 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134532.0 ave 134532 max 134532 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134532 Ave neighs/atom = 67.266000 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.703396166549, Press = -0.631322409580152 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 111000 -10443.976 -10443.976 -10520.574 -10520.574 296.4433 296.4433 28056.775 28056.775 -1009.2676 -1009.2676 112000 -10444.794 -10444.794 -10520.839 -10520.839 294.30236 294.30236 28012.292 28012.292 1472.1793 1472.1793 Loop time of 176.928 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.147 hours/ns, 5.652 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 | 176.39 | 176.39 | 176.39 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098944 | 0.098944 | 0.098944 | 0.0 | 0.06 Output | 0.00018932 | 0.00018932 | 0.00018932 | 0.0 | 0.00 Modify | 0.37299 | 0.37299 | 0.37299 | 0.0 | 0.21 Other | | 0.06154 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134734.0 ave 134734 max 134734 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134734 Ave neighs/atom = 67.367000 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.705070207502, Press = -0.013284467711726 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 112000 -10444.794 -10444.794 -10520.839 -10520.839 294.30236 294.30236 28012.292 28012.292 1472.1793 1472.1793 113000 -10440.981 -10440.981 -10518.814 -10518.814 301.22524 301.22524 28058.808 28058.808 -896.6849 -896.6849 Loop time of 176.96 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.156 hours/ns, 5.651 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 | 176.42 | 176.42 | 176.42 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099717 | 0.099717 | 0.099717 | 0.0 | 0.06 Output | 0.0001609 | 0.0001609 | 0.0001609 | 0.0 | 0.00 Modify | 0.37632 | 0.37632 | 0.37632 | 0.0 | 0.21 Other | | 0.06173 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135046.0 ave 135046 max 135046 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135046 Ave neighs/atom = 67.523000 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.730246564198, Press = 0.0566791496516128 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 113000 -10440.981 -10440.981 -10518.814 -10518.814 301.22524 301.22524 28058.808 28058.808 -896.6849 -896.6849 114000 -10444.891 -10444.891 -10519.232 -10519.232 287.70497 287.70497 28044.271 28044.271 -268.99315 -268.99315 Loop time of 173.486 on 1 procs for 1000 steps with 2000 atoms Performance: 0.498 ns/day, 48.191 hours/ns, 5.764 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 | 172.96 | 172.96 | 172.96 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097774 | 0.097774 | 0.097774 | 0.0 | 0.06 Output | 0.00019212 | 0.00019212 | 0.00019212 | 0.0 | 0.00 Modify | 0.36525 | 0.36525 | 0.36525 | 0.0 | 0.21 Other | | 0.06087 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134968.0 ave 134968 max 134968 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134968 Ave neighs/atom = 67.484000 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.732760264049, Press = -0.243064265979502 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 114000 -10444.891 -10444.891 -10519.232 -10519.232 287.70497 287.70497 28044.271 28044.271 -268.99315 -268.99315 115000 -10444.784 -10444.784 -10520.135 -10520.135 291.6148 291.6148 28026.914 28026.914 815.44894 815.44894 Loop time of 175.58 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.772 hours/ns, 5.695 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 | 175.05 | 175.05 | 175.05 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099213 | 0.099213 | 0.099213 | 0.0 | 0.06 Output | 0.00015536 | 0.00015536 | 0.00015536 | 0.0 | 0.00 Modify | 0.37062 | 0.37062 | 0.37062 | 0.0 | 0.21 Other | | 0.06108 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135118.0 ave 135118 max 135118 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135118 Ave neighs/atom = 67.559000 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.752561005025, Press = -0.107701739829409 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 115000 -10444.784 -10444.784 -10520.135 -10520.135 291.6148 291.6148 28026.914 28026.914 815.44894 815.44894 116000 -10446.07 -10446.07 -10521.093 -10521.093 290.34779 290.34779 28049.299 28049.299 -511.3897 -511.3897 Loop time of 175.262 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.684 hours/ns, 5.706 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 | 174.73 | 174.73 | 174.73 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098187 | 0.098187 | 0.098187 | 0.0 | 0.06 Output | 0.00015607 | 0.00015607 | 0.00015607 | 0.0 | 0.00 Modify | 0.36852 | 0.36852 | 0.36852 | 0.0 | 0.21 Other | | 0.06125 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134816.0 ave 134816 max 134816 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134816 Ave neighs/atom = 67.408000 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.750370203534, Press = -0.0136926317295519 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 116000 -10446.07 -10446.07 -10521.093 -10521.093 290.34779 290.34779 28049.299 28049.299 -511.3897 -511.3897 117000 -10443.459 -10443.459 -10519.19 -10519.19 293.08746 293.08746 28040.494 28040.494 23.079066 23.079066 Loop time of 175.437 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.732 hours/ns, 5.700 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 | 174.91 | 174.91 | 174.91 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099359 | 0.099359 | 0.099359 | 0.0 | 0.06 Output | 0.00019691 | 0.00019691 | 0.00019691 | 0.0 | 0.00 Modify | 0.36922 | 0.36922 | 0.36922 | 0.0 | 0.21 Other | | 0.06079 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134724.0 ave 134724 max 134724 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134724 Ave neighs/atom = 67.362000 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.754555665614, Press = -0.609785976682305 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 117000 -10443.459 -10443.459 -10519.19 -10519.19 293.08746 293.08746 28040.494 28040.494 23.079066 23.079066 118000 -10443.494 -10443.494 -10519.723 -10519.723 295.01494 295.01494 28003.294 28003.294 2149.8242 2149.8242 Loop time of 174.079 on 1 procs for 1000 steps with 2000 atoms Performance: 0.496 ns/day, 48.355 hours/ns, 5.745 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 173.56 | 173.56 | 173.56 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097015 | 0.097015 | 0.097015 | 0.0 | 0.06 Output | 0.00015183 | 0.00015183 | 0.00015183 | 0.0 | 0.00 Modify | 0.36159 | 0.36159 | 0.36159 | 0.0 | 0.21 Other | | 0.06083 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134954.0 ave 134954 max 134954 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134954 Ave neighs/atom = 67.477000 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.740219914508, Press = 0.273681471322072 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 118000 -10443.494 -10443.494 -10519.723 -10519.723 295.01494 295.01494 28003.294 28003.294 2149.8242 2149.8242 119000 -10447.35 -10447.35 -10522.59 -10522.59 291.18534 291.18534 28078.419 28078.419 -2255.5214 -2255.5214 Loop time of 175.309 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.697 hours/ns, 5.704 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 | 174.78 | 174.78 | 174.78 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098526 | 0.098526 | 0.098526 | 0.0 | 0.06 Output | 0.0002151 | 0.0002151 | 0.0002151 | 0.0 | 0.00 Modify | 0.36846 | 0.36846 | 0.36846 | 0.0 | 0.21 Other | | 0.06087 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135068.0 ave 135068 max 135068 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135068 Ave neighs/atom = 67.534000 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.738877231422, Press = 0.0322856742989006 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 119000 -10447.35 -10447.35 -10522.59 -10522.59 291.18534 291.18534 28078.419 28078.419 -2255.5214 -2255.5214 120000 -10443.683 -10443.683 -10519.323 -10519.323 292.73794 292.73794 28036.519 28036.519 389.56349 389.56349 Loop time of 177.493 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.303 hours/ns, 5.634 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 | 176.95 | 176.95 | 176.95 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10048 | 0.10048 | 0.10048 | 0.0 | 0.06 Output | 0.00015852 | 0.00015852 | 0.00015852 | 0.0 | 0.00 Modify | 0.38027 | 0.38027 | 0.38027 | 0.0 | 0.21 Other | | 0.06196 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134446.0 ave 134446 max 134446 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134446 Ave neighs/atom = 67.223000 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.743098043083, Press = -0.434163772824773 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 120000 -10443.683 -10443.683 -10519.323 -10519.323 292.73794 292.73794 28036.519 28036.519 389.56349 389.56349 121000 -10444.31 -10444.31 -10520.008 -10520.008 292.96002 292.96002 28029.129 28029.129 763.19665 763.19665 Loop time of 176.632 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.064 hours/ns, 5.661 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 | 176.1 | 176.1 | 176.1 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098925 | 0.098925 | 0.098925 | 0.0 | 0.06 Output | 0.00015637 | 0.00015637 | 0.00015637 | 0.0 | 0.00 Modify | 0.37286 | 0.37286 | 0.37286 | 0.0 | 0.21 Other | | 0.06142 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134926.0 ave 134926 max 134926 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134926 Ave neighs/atom = 67.463000 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.757010815777, Press = 0.00152448994971248 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 121000 -10444.31 -10444.31 -10520.008 -10520.008 292.96002 292.96002 28029.129 28029.129 763.19665 763.19665 122000 -10445.874 -10445.874 -10521.541 -10521.541 292.83671 292.83671 28040.41 28040.41 -194.98315 -194.98315 Loop time of 175.982 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.884 hours/ns, 5.682 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 | 175.45 | 175.45 | 175.45 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09903 | 0.09903 | 0.09903 | 0.0 | 0.06 Output | 0.00015596 | 0.00015596 | 0.00015596 | 0.0 | 0.00 Modify | 0.36982 | 0.36982 | 0.36982 | 0.0 | 0.21 Other | | 0.06116 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134832.0 ave 134832 max 134832 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134832 Ave neighs/atom = 67.416000 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.780383725868, Press = -0.112387566017671 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 122000 -10445.874 -10445.874 -10521.541 -10521.541 292.83671 292.83671 28040.41 28040.41 -194.98315 -194.98315 123000 -10440.293 -10440.293 -10517.026 -10517.026 296.96269 296.96269 28046.225 28046.225 -4.6327994 -4.6327994 Loop time of 173.976 on 1 procs for 1000 steps with 2000 atoms Performance: 0.497 ns/day, 48.327 hours/ns, 5.748 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 | 173.45 | 173.45 | 173.45 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098588 | 0.098588 | 0.098588 | 0.0 | 0.06 Output | 0.00015181 | 0.00015181 | 0.00015181 | 0.0 | 0.00 Modify | 0.36481 | 0.36481 | 0.36481 | 0.0 | 0.21 Other | | 0.06062 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134802.0 ave 134802 max 134802 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134802 Ave neighs/atom = 67.401000 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.791620437978, Press = -0.236454966275399 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 123000 -10440.293 -10440.293 -10517.026 -10517.026 296.96269 296.96269 28046.225 28046.225 -4.6327994 -4.6327994 124000 -10445.132 -10445.132 -10520.716 -10520.716 292.51761 292.51761 28008.316 28008.316 1565.255 1565.255 Loop time of 174.807 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.557 hours/ns, 5.721 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 | 174.28 | 174.28 | 174.28 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098945 | 0.098945 | 0.098945 | 0.0 | 0.06 Output | 0.00015732 | 0.00015732 | 0.00015732 | 0.0 | 0.00 Modify | 0.36939 | 0.36939 | 0.36939 | 0.0 | 0.21 Other | | 0.06136 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135054.0 ave 135054 max 135054 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135054 Ave neighs/atom = 67.527000 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.810929188315, Press = 0.0433188387642817 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 124000 -10445.132 -10445.132 -10520.716 -10520.716 292.51761 292.51761 28008.316 28008.316 1565.255 1565.255 125000 -10438.379 -10438.379 -10517.052 -10517.052 304.47519 304.47519 28082.173 28082.173 -1927.8561 -1927.8561 Loop time of 178.224 on 1 procs for 1000 steps with 2000 atoms Performance: 0.485 ns/day, 49.507 hours/ns, 5.611 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 | 177.68 | 177.68 | 177.68 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10161 | 0.10161 | 0.10161 | 0.0 | 0.06 Output | 0.00015648 | 0.00015648 | 0.00015648 | 0.0 | 0.00 Modify | 0.37848 | 0.37848 | 0.37848 | 0.0 | 0.21 Other | | 0.06254 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135198.0 ave 135198 max 135198 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135198 Ave neighs/atom = 67.599000 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.828295280445, Press = 0.11274616695935 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 125000 -10438.379 -10438.379 -10517.052 -10517.052 304.47519 304.47519 28082.173 28082.173 -1927.8561 -1927.8561 126000 -10446.116 -10446.116 -10520.988 -10520.988 289.76404 289.76404 28041.775 28041.775 -215.47133 -215.47133 Loop time of 175.056 on 1 procs for 1000 steps with 2000 atoms Performance: 0.494 ns/day, 48.627 hours/ns, 5.712 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 | 174.52 | 174.52 | 174.52 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09908 | 0.09908 | 0.09908 | 0.0 | 0.06 Output | 0.00015592 | 0.00015592 | 0.00015592 | 0.0 | 0.00 Modify | 0.3711 | 0.3711 | 0.3711 | 0.0 | 0.21 Other | | 0.06138 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134896.0 ave 134896 max 134896 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134896 Ave neighs/atom = 67.448000 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.838337154152, Press = -0.687788904691075 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 126000 -10446.116 -10446.116 -10520.988 -10520.988 289.76404 289.76404 28041.775 28041.775 -215.47133 -215.47133 127000 -10443.988 -10443.988 -10521.044 -10521.044 298.21736 298.21736 28003.42 28003.42 1976.2877 1976.2877 Loop time of 177.074 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.187 hours/ns, 5.647 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 | 176.53 | 176.53 | 176.53 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099743 | 0.099743 | 0.099743 | 0.0 | 0.06 Output | 0.0001563 | 0.0001563 | 0.0001563 | 0.0 | 0.00 Modify | 0.37826 | 0.37826 | 0.37826 | 0.0 | 0.21 Other | | 0.06175 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134792.0 ave 134792 max 134792 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134792 Ave neighs/atom = 67.396000 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.844104714898, Press = 0.108439849347349 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 127000 -10443.988 -10443.988 -10521.044 -10521.044 298.21736 298.21736 28003.42 28003.42 1976.2877 1976.2877 128000 -10440.193 -10440.193 -10516.472 -10516.472 295.20837 295.20837 28070.268 28070.268 -1190.6352 -1190.6352 Loop time of 176.852 on 1 procs for 1000 steps with 2000 atoms Performance: 0.489 ns/day, 49.126 hours/ns, 5.654 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 | 176.31 | 176.31 | 176.31 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.1007 | 0.1007 | 0.1007 | 0.0 | 0.06 Output | 0.00015523 | 0.00015523 | 0.00015523 | 0.0 | 0.00 Modify | 0.37639 | 0.37639 | 0.37639 | 0.0 | 0.21 Other | | 0.06154 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135076.0 ave 135076 max 135076 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135076 Ave neighs/atom = 67.538000 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.859885598848, Press = 0.0308154060551764 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 128000 -10440.193 -10440.193 -10516.472 -10516.472 295.20837 295.20837 28070.268 28070.268 -1190.6352 -1190.6352 129000 -10446.656 -10446.656 -10521.683 -10521.683 290.35884 290.35884 28033.308 28033.308 349.90471 349.90471 Loop time of 175.269 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.686 hours/ns, 5.706 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 | 174.74 | 174.74 | 174.74 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098637 | 0.098637 | 0.098637 | 0.0 | 0.06 Output | 0.00021427 | 0.00021427 | 0.00021427 | 0.0 | 0.00 Modify | 0.3681 | 0.3681 | 0.3681 | 0.0 | 0.21 Other | | 0.06069 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134934.0 ave 134934 max 134934 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134934 Ave neighs/atom = 67.467000 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.878955652126, Press = -0.327628640863794 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 129000 -10446.656 -10446.656 -10521.683 -10521.683 290.35884 290.35884 28033.308 28033.308 349.90471 349.90471 130000 -10447.413 -10447.413 -10520.988 -10520.988 284.73972 284.73972 28021.754 28021.754 852.60255 852.60255 Loop time of 172.684 on 1 procs for 1000 steps with 2000 atoms Performance: 0.500 ns/day, 47.968 hours/ns, 5.791 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 | 172.16 | 172.16 | 172.16 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09772 | 0.09772 | 0.09772 | 0.0 | 0.06 Output | 0.00015454 | 0.00015454 | 0.00015454 | 0.0 | 0.00 Modify | 0.36183 | 0.36183 | 0.36183 | 0.0 | 0.21 Other | | 0.06051 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134706.0 ave 134706 max 134706 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134706 Ave neighs/atom = 67.353000 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.870164260175, Press = -0.0120304728634973 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 130000 -10447.413 -10447.413 -10520.988 -10520.988 284.73972 284.73972 28021.754 28021.754 852.60255 852.60255 131000 -10445.933 -10445.933 -10522.069 -10522.069 294.65531 294.65531 28056.918 28056.918 -1112.8258 -1112.8258 Loop time of 173.154 on 1 procs for 1000 steps with 2000 atoms Performance: 0.499 ns/day, 48.098 hours/ns, 5.775 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 | 172.63 | 172.63 | 172.63 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09851 | 0.09851 | 0.09851 | 0.0 | 0.06 Output | 0.00014946 | 0.00014946 | 0.00014946 | 0.0 | 0.00 Modify | 0.36603 | 0.36603 | 0.36603 | 0.0 | 0.21 Other | | 0.0609 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134962.0 ave 134962 max 134962 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134962 Ave neighs/atom = 67.481000 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.874737862073, Press = -0.124032074723317 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 131000 -10445.933 -10445.933 -10522.069 -10522.069 294.65531 294.65531 28056.918 28056.918 -1112.8258 -1112.8258 132000 -10440.749 -10440.749 -10520.704 -10520.704 309.43576 309.43576 28026.268 28026.268 981.2224 981.2224 Loop time of 175.531 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.759 hours/ns, 5.697 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 | 175 | 175 | 175 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099442 | 0.099442 | 0.099442 | 0.0 | 0.06 Output | 0.00019471 | 0.00019471 | 0.00019471 | 0.0 | 0.00 Modify | 0.37349 | 0.37349 | 0.37349 | 0.0 | 0.21 Other | | 0.06174 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134666.0 ave 134666 max 134666 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134666 Ave neighs/atom = 67.333000 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.893916322414, Press = -0.649916882444264 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 132000 -10440.749 -10440.749 -10520.704 -10520.704 309.43576 309.43576 28026.268 28026.268 981.2224 981.2224 133000 -10444.635 -10444.635 -10521.001 -10521.001 295.54542 295.54542 28011.527 28011.527 1550.8108 1550.8108 Loop time of 173.372 on 1 procs for 1000 steps with 2000 atoms Performance: 0.498 ns/day, 48.159 hours/ns, 5.768 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 | 172.85 | 172.85 | 172.85 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097822 | 0.097822 | 0.097822 | 0.0 | 0.06 Output | 0.00015579 | 0.00015579 | 0.00015579 | 0.0 | 0.00 Modify | 0.36529 | 0.36529 | 0.36529 | 0.0 | 0.21 Other | | 0.06084 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134862.0 ave 134862 max 134862 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134862 Ave neighs/atom = 67.431000 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.900361630881, Press = 0.587807957406047 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 133000 -10444.635 -10444.635 -10521.001 -10521.001 295.54542 295.54542 28011.527 28011.527 1550.8108 1550.8108 134000 -10443.927 -10443.927 -10520.894 -10520.894 297.87163 297.87163 28083.944 28083.944 -2311.8265 -2311.8265 Loop time of 176.225 on 1 procs for 1000 steps with 2000 atoms Performance: 0.490 ns/day, 48.951 hours/ns, 5.675 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 | 175.7 | 175.7 | 175.7 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099085 | 0.099085 | 0.099085 | 0.0 | 0.06 Output | 0.00015617 | 0.00015617 | 0.00015617 | 0.0 | 0.00 Modify | 0.36613 | 0.36613 | 0.36613 | 0.0 | 0.21 Other | | 0.0608 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134916.0 ave 134916 max 134916 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134916 Ave neighs/atom = 67.458000 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.91519667379, Press = -0.209793161731948 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 134000 -10443.927 -10443.927 -10520.894 -10520.894 297.87163 297.87163 28083.944 28083.944 -2311.8265 -2311.8265 135000 -10440.508 -10440.508 -10517.387 -10517.387 297.52966 297.52966 28027.985 28027.985 1183.7863 1183.7863 Loop time of 171.756 on 1 procs for 1000 steps with 2000 atoms Performance: 0.503 ns/day, 47.710 hours/ns, 5.822 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 | 171.24 | 171.24 | 171.24 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098163 | 0.098163 | 0.098163 | 0.0 | 0.06 Output | 0.00015481 | 0.00015481 | 0.00015481 | 0.0 | 0.00 Modify | 0.35994 | 0.35994 | 0.35994 | 0.0 | 0.21 Other | | 0.0601 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134418.0 ave 134418 max 134418 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134418 Ave neighs/atom = 67.209000 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.918379209825, Press = -0.33321107901521 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 135000 -10440.508 -10440.508 -10517.387 -10517.387 297.52966 297.52966 28027.985 28027.985 1183.7863 1183.7863 136000 -10445.39 -10445.39 -10520.649 -10520.649 291.26048 291.26048 28029.135 28029.135 692.81357 692.81357 Loop time of 177.269 on 1 procs for 1000 steps with 2000 atoms Performance: 0.487 ns/day, 49.241 hours/ns, 5.641 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 | 176.73 | 176.73 | 176.73 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099781 | 0.099781 | 0.099781 | 0.0 | 0.06 Output | 0.00015503 | 0.00015503 | 0.00015503 | 0.0 | 0.00 Modify | 0.37649 | 0.37649 | 0.37649 | 0.0 | 0.21 Other | | 0.06232 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135150.0 ave 135150 max 135150 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135150 Ave neighs/atom = 67.575000 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.935611636495, Press = 0.160014907528645 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 136000 -10445.39 -10445.39 -10520.649 -10520.649 291.26048 291.26048 28029.135 28029.135 692.81357 692.81357 137000 -10444.834 -10444.834 -10520.532 -10520.532 292.95713 292.95713 28080.843 28080.843 -2259.8121 -2259.8121 Loop time of 174.687 on 1 procs for 1000 steps with 2000 atoms Performance: 0.495 ns/day, 48.524 hours/ns, 5.725 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 | 174.16 | 174.16 | 174.16 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098799 | 0.098799 | 0.098799 | 0.0 | 0.06 Output | 0.00015406 | 0.00015406 | 0.00015406 | 0.0 | 0.00 Modify | 0.36579 | 0.36579 | 0.36579 | 0.0 | 0.21 Other | | 0.06104 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135018.0 ave 135018 max 135018 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135018 Ave neighs/atom = 67.509000 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.949763679278, Press = -0.2005894841077 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 137000 -10444.834 -10444.834 -10520.532 -10520.532 292.95713 292.95713 28080.843 28080.843 -2259.8121 -2259.8121 138000 -10444.869 -10444.869 -10521.819 -10521.819 297.80324 297.80324 28001.547 28001.547 2010.0235 2010.0235 Loop time of 175.602 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.778 hours/ns, 5.695 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 | 175.06 | 175.06 | 175.06 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10019 | 0.10019 | 0.10019 | 0.0 | 0.06 Output | 0.00019083 | 0.00019083 | 0.00019083 | 0.0 | 0.00 Modify | 0.3768 | 0.3768 | 0.3768 | 0.0 | 0.21 Other | | 0.06156 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134456.0 ave 134456 max 134456 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134456 Ave neighs/atom = 67.228000 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.940470022937, Press = -0.886328729803692 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 138000 -10444.869 -10444.869 -10521.819 -10521.819 297.80324 297.80324 28001.547 28001.547 2010.0235 2010.0235 139000 -10445.23 -10445.23 -10521.581 -10521.581 295.48746 295.48746 28007.703 28007.703 1706.6901 1706.6901 Loop time of 176.947 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.152 hours/ns, 5.651 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 | 176.41 | 176.41 | 176.41 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.1006 | 0.1006 | 0.1006 | 0.0 | 0.06 Output | 0.00015578 | 0.00015578 | 0.00015578 | 0.0 | 0.00 Modify | 0.37674 | 0.37674 | 0.37674 | 0.0 | 0.21 Other | | 0.06171 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135060.0 ave 135060 max 135060 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135060 Ave neighs/atom = 67.530000 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.941723772379, Press = 0.341506701786356 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 139000 -10445.23 -10445.23 -10521.581 -10521.581 295.48746 295.48746 28007.703 28007.703 1706.6901 1706.6901 140000 -10445.29 -10445.29 -10519.584 -10519.584 287.52457 287.52457 28073.256 28073.256 -1722.3753 -1722.3753 Loop time of 176.218 on 1 procs for 1000 steps with 2000 atoms Performance: 0.490 ns/day, 48.949 hours/ns, 5.675 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 | 175.69 | 175.69 | 175.69 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098608 | 0.098608 | 0.098608 | 0.0 | 0.06 Output | 0.00026059 | 0.00026059 | 0.00026059 | 0.0 | 0.00 Modify | 0.37015 | 0.37015 | 0.37015 | 0.0 | 0.21 Other | | 0.06149 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135074.0 ave 135074 max 135074 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135074 Ave neighs/atom = 67.537000 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.924926218697, Press = 0.0435045115656134 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 140000 -10445.29 -10445.29 -10519.584 -10519.584 287.52457 287.52457 28073.256 28073.256 -1722.3753 -1722.3753 141000 -10442.852 -10442.852 -10519.887 -10519.887 298.13408 298.13408 28043.331 28043.331 -108.31077 -108.31077 Loop time of 175.446 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.735 hours/ns, 5.700 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 | 174.91 | 174.91 | 174.91 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099531 | 0.099531 | 0.099531 | 0.0 | 0.06 Output | 0.00015537 | 0.00015537 | 0.00015537 | 0.0 | 0.00 Modify | 0.37247 | 0.37247 | 0.37247 | 0.0 | 0.21 Other | | 0.06143 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134502.0 ave 134502 max 134502 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134502 Ave neighs/atom = 67.251000 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.932874473941, Press = -0.379785703746625 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 141000 -10442.852 -10442.852 -10519.887 -10519.887 298.13408 298.13408 28043.331 28043.331 -108.31077 -108.31077 142000 -10446.804 -10446.804 -10524.552 -10524.552 300.89294 300.89294 28014.615 28014.615 1065.162 1065.162 Loop time of 177.013 on 1 procs for 1000 steps with 2000 atoms Performance: 0.488 ns/day, 49.170 hours/ns, 5.649 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 | 176.48 | 176.48 | 176.48 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09954 | 0.09954 | 0.09954 | 0.0 | 0.06 Output | 0.00015782 | 0.00015782 | 0.00015782 | 0.0 | 0.00 Modify | 0.37544 | 0.37544 | 0.37544 | 0.0 | 0.21 Other | | 0.06139 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134958.0 ave 134958 max 134958 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134958 Ave neighs/atom = 67.479000 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.928122196936, Press = 0.134215602451742 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 142000 -10446.804 -10446.804 -10524.552 -10524.552 300.89294 300.89294 28014.615 28014.615 1065.162 1065.162 143000 -10443.958 -10443.958 -10520.391 -10520.391 295.80408 295.80408 28091.548 28091.548 -2762.6343 -2762.6343 Loop time of 175.855 on 1 procs for 1000 steps with 2000 atoms Performance: 0.491 ns/day, 48.849 hours/ns, 5.687 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 | 175.32 | 175.32 | 175.32 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.099254 | 0.099254 | 0.099254 | 0.0 | 0.06 Output | 0.00015373 | 0.00015373 | 0.00015373 | 0.0 | 0.00 Modify | 0.37122 | 0.37122 | 0.37122 | 0.0 | 0.21 Other | | 0.0615 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134712.0 ave 134712 max 134712 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134712 Ave neighs/atom = 67.356000 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.926170743854, Press = 0.10901022666855 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 143000 -10443.958 -10443.958 -10520.391 -10520.391 295.80408 295.80408 28091.548 28091.548 -2762.6343 -2762.6343 144000 -10447.481 -10447.481 -10520.745 -10520.745 283.54067 283.54067 28037.134 28037.134 126.86543 126.86543 Loop time of 175.15 on 1 procs for 1000 steps with 2000 atoms Performance: 0.493 ns/day, 48.653 hours/ns, 5.709 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 | 174.62 | 174.62 | 174.62 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.09955 | 0.09955 | 0.09955 | 0.0 | 0.06 Output | 0.00015552 | 0.00015552 | 0.00015552 | 0.0 | 0.00 Modify | 0.36992 | 0.36992 | 0.36992 | 0.0 | 0.21 Other | | 0.06089 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134414.0 ave 134414 max 134414 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134414 Ave neighs/atom = 67.207000 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.912211963867, Press = -0.764739190042602 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 144000 -10447.481 -10447.481 -10520.745 -10520.745 283.54067 283.54067 28037.134 28037.134 126.86543 126.86543 145000 -10444.833 -10444.833 -10520.106 -10520.106 291.31278 291.31278 28013.575 28013.575 1683.9084 1683.9084 Loop time of 179.898 on 1 procs for 1000 steps with 2000 atoms Performance: 0.480 ns/day, 49.972 hours/ns, 5.559 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 | 179.35 | 179.35 | 179.35 | 0.0 | 99.69 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.10144 | 0.10144 | 0.10144 | 0.0 | 0.06 Output | 0.00015629 | 0.00015629 | 0.00015629 | 0.0 | 0.00 Modify | 0.38697 | 0.38697 | 0.38697 | 0.0 | 0.22 Other | | 0.06186 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134862.0 ave 134862 max 134862 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134862 Ave neighs/atom = 67.431000 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.921385600354, Press = 0.139072494245139 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 145000 -10444.833 -10444.833 -10520.106 -10520.106 291.31278 291.31278 28013.575 28013.575 1683.9084 1683.9084 146000 -10446.855 -10446.855 -10521.206 -10521.206 287.74549 287.74549 28058.379 28058.379 -971.87887 -971.87887 Loop time of 175.546 on 1 procs for 1000 steps with 2000 atoms Performance: 0.492 ns/day, 48.763 hours/ns, 5.697 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 | 175.01 | 175.01 | 175.01 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.098864 | 0.098864 | 0.098864 | 0.0 | 0.06 Output | 0.0001537 | 0.0001537 | 0.0001537 | 0.0 | 0.00 Modify | 0.3705 | 0.3705 | 0.3705 | 0.0 | 0.21 Other | | 0.06121 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134968.0 ave 134968 max 134968 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134968 Ave neighs/atom = 67.484000 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.942647806066, Press = 0.0626370040331776 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 146000 -10446.855 -10446.855 -10521.206 -10521.206 287.74549 287.74549 28058.379 28058.379 -971.87887 -971.87887 147000 -10444.023 -10444.023 -10518.467 -10518.467 288.10845 288.10845 28044.052 28044.052 156.63363 156.63363 Loop time of 172.422 on 1 procs for 1000 steps with 2000 atoms Performance: 0.501 ns/day, 47.895 hours/ns, 5.800 timesteps/s 100.0% CPU use with 1 MPI tasks x 1 OpenMP threads MPI task timing breakdown: Section | min time | avg time | max time |%varavg| %total --------------------------------------------------------------- Pair | 171.9 | 171.9 | 171.9 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097432 | 0.097432 | 0.097432 | 0.0 | 0.06 Output | 0.00020839 | 0.00020839 | 0.00020839 | 0.0 | 0.00 Modify | 0.36085 | 0.36085 | 0.36085 | 0.0 | 0.21 Other | | 0.06101 | | | 0.04 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 134444.0 ave 134444 max 134444 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 134444 Ave neighs/atom = 67.222000 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.948368114569, Press = -0.356042774583884 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 = 6.5 ghost atom cutoff = 6.5 binsize = 3.25, bins = 10 10 10 1 neighbor lists, perpetual/occasional/extra = 1 0 0 (1) pair kim, perpetual attributes: full, newton off, cut 6.5 pair build: full/bin/atomonly stencil: full/bin/3d bin: standard Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 147000 -10444.023 -10444.023 -10518.467 -10518.467 288.10845 288.10845 28044.052 28044.052 156.63363 156.63363 148000 -10445.27 -10445.27 -10521.656 -10521.656 295.62399 295.62399 28007.41 28007.41 1749.5846 1749.5846 Loop time of 173.062 on 1 procs for 1000 steps with 2000 atoms Performance: 0.499 ns/day, 48.073 hours/ns, 5.778 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 | 172.54 | 172.54 | 172.54 | 0.0 | 99.70 Neigh | 0 | 0 | 0 | 0.0 | 0.00 Comm | 0.097559 | 0.097559 | 0.097559 | 0.0 | 0.06 Output | 0.00019531 | 0.00019531 | 0.00019531 | 0.0 | 0.00 Modify | 0.36284 | 0.36284 | 0.36284 | 0.0 | 0.21 Other | | 0.06048 | | | 0.03 Nlocal: 2000.00 ave 2000 max 2000 min Histogram: 1 0 0 0 0 0 0 0 0 0 Nghost: 4119.00 ave 4119 max 4119 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: 135030.0 ave 135030 max 135030 min Histogram: 1 0 0 0 0 0 0 0 0 0 Total # of neighbors = 135030 Ave neighs/atom = 67.515000 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 28041.0190829827 print "LAMMPS calculation completed" LAMMPS calculation completed quit 0